@pronto-tools-and-more/pronto 3.3.8

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@pronto-tools-and-more/pronto",
+  "version": "3.3.8",
+  "description": "",
+  "main": "src/main.js",
+  "type": "module",
+  "scripts": {
+    "test": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --detectOpenHandles --forceExit",
+    "test:watch": "node --unhandled-rejections=warn --experimental-vm-modules ./node_modules/jest/bin/jest.js --watch",
+    "type-check": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@pronto-tools-and-more/file-watcher": "3.3.8",
+    "@pronto-tools-and-more/files": "3.3.8",
+    "@pronto-tools-and-more/network-process": "3.3.8",
+    "@pronto-tools-and-more/sass-compiler": "3.3.8",
+    "@lvce-editor/assert": "^1.2.0",
+    "@lvce-editor/ipc": "^9.1.0",
+    "@lvce-editor/json-rpc": "^1.3.0",
+    "@lvce-editor/verror": "^1.3.0",
+    "execa": "^9.1.0",
+    "express": "^4.19.2"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.21",
+    "@types/node": "^20.12.7",
+    "@types/ws": "^8.5.10",
+    "jest": "^29.7.0"
+  },
+  "jest": {
+    "injectGlobals": false
+  }
+}

package/src/main.js

@@ -0,0 +1,3 @@
+import * as Main from "./parts/Main/Main.js";
+
+Main.main();

package/src/parts/App/App.js

@@ -0,0 +1,54 @@
+import express from "express";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import * as CompileSass from "../CompileSass/CompileSass.js";
+import * as Config from "../Config/Config.js";
+import * as FilesPath from "../FilesPath/FilesPath.js";
+import * as UpdateCss from "../UpdateCss/UpdateCss.js";
+import * as UpdateIndexHtml from "../UpdateIndexHtml/UpdateIndexHtml.js";
+
+const handleIndex = (storeFrontPath) => async (req, res) => {
+  const indexHtmlPath = join(storeFrontPath, "index.html");
+  const indexHtmlContent = await readFile(indexHtmlPath, "utf8");
+  const newIndexHtml = UpdateIndexHtml.updateIndexHtml(indexHtmlContent);
+  res.end(newIndexHtml);
+};
+
+const handleCss = (storeFrontPath) => async (req, res, next) => {
+  const pathName = req._parsedUrl.pathname;
+  if (!pathName.endsWith(".css")) {
+    return next();
+  }
+  if (pathName === "/assets/custom.css") {
+    try {
+      const result = await CompileSass.compileSass(Config.rootSassFile);
+      res.end(result.css);
+    } catch (error) {
+      console.warn(error);
+      res.end(`css error: ${error}`);
+    }
+    return;
+  }
+  const cssPath = join(storeFrontPath, pathName);
+  if (!existsSync(cssPath)) {
+    return next();
+  }
+  const cssContent = await readFile(cssPath, "utf8");
+  const newCss = UpdateCss.updateCss(cssContent);
+  res.end(newCss);
+};
+
+export const create = (root) => {
+  const app = express();
+  const storeFrontPath = join(root, "src", "default", "storefront");
+  const defaultPath = join(root, "src", "default");
+  const contentPath = join(root, "src", "default", "content");
+  app.get("/", handleIndex(storeFrontPath));
+  app.use("*", handleCss(storeFrontPath));
+  app.use(express.static(FilesPath.filesPath));
+  app.use(express.static(storeFrontPath));
+  app.use(express.static(defaultPath));
+  app.use(express.static(contentPath));
+  return app;
+};

package/src/parts/Assert/Assert.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/assert";

package/src/parts/Build/Build.js

@@ -0,0 +1,24 @@
+import { VError } from "@lvce-editor/verror";
+import { writeFile } from "fs/promises";
+import * as CompileSass from "../CompileSass/CompileSass.js";
+import * as Config from "../Config/Config.js";
+import * as SassProcess from "../SassProcess/SassProcess.js";
+
+const sourceMap = false;
+
+export const build = async () => {
+  try {
+    const result = await CompileSass.compileSass(Config.rootSassFile, {
+      updateDynamicResources: false,
+      sourceMap,
+    });
+    const css = result.css + "\n\n/*# sourceMappingURL=custom.css.map */\n";
+    await writeFile(Config.rootCssFile, css);
+    const rootCssMapFile = Config.rootCssFile + ".map";
+    await writeFile(rootCssMapFile, JSON.stringify(result.sourceMap) + "\n");
+  } catch (error) {
+    throw new VError(error, `Failed to build`);
+  } finally {
+    SassProcess.dispose();
+  }
+};

package/src/parts/Callback/Callback.js

@@ -0,0 +1 @@
+export { resolve } from "@lvce-editor/json-rpc";

package/src/parts/ChangeWatcher/ChangeWatcher.js

@@ -0,0 +1,51 @@
+import { rm } from "node:fs/promises";
+import * as net from "node:net";
+import * as SendSassUpdates from "../SendSassUpdates/SendSassUpdates.js";
+import { fileURLToPath } from "node:url";
+
+const SOCKET_FILE = "/tmp/pronto.sock";
+
+const canHandle = (data) => {
+  const dataContent = data.toString();
+  try {
+    return JSON.parse(dataContent);
+  } catch {
+    return false;
+  }
+};
+
+const handleData = async (clients, chunks, data) => {
+  chunks.push(data);
+  const buffer = Buffer.concat(chunks);
+  const parsed = canHandle(buffer);
+  if (!parsed) {
+    return;
+  }
+  chunks.length = 0;
+  const uri = parsed.params[0];
+  const path = fileURLToPath(uri);
+  const content = parsed.params[1];
+  await SendSassUpdates.sendSassUpdates(clients, path, content);
+};
+
+export const create = async (webSocketServer) => {
+  try {
+    await rm(SOCKET_FILE, { force: true });
+
+    /**
+     *
+     * @param {net.Socket} connection
+     */
+    const handleConnection = (connection) => {
+      const chunks = [];
+      connection.on("data", (data) => {
+        handleData(webSocketServer.clients, chunks, data);
+      });
+    };
+
+    const server = net.createServer(handleConnection);
+    server.listen(SOCKET_FILE);
+  } catch (error) {
+    console.warn(`Failed to create change watcher: ${error}`);
+  }
+};

package/src/parts/Command/Command.js

@@ -0,0 +1,9 @@
+import * as CommandMap from "../CommandMap/CommandMap.js";
+
+export const execute = (method, ...params) => {
+  const command = CommandMap.commandMap[method];
+  if (!command) {
+    throw new Error(`command not found ${method}`);
+  }
+  return command(...params);
+};

package/src/parts/CommandMap/CommandMap.js

@@ -0,0 +1,15 @@
+import * as Build from "../Build/Build.js";
+import * as Login from "../Login/Login.js";
+import * as PullCode from "../PullCode/PullCode.js";
+import * as PushCode from "../PushCode/PushCode.js";
+import * as Server from "../Server/Server.js";
+import * as UploadZip from "../UploadZip/UploadZip.js";
+
+export const commandMap = {
+  "Build.build": Build.build,
+  "Login.login": Login.login,
+  "PullCode.pullCode": PullCode.pullCode,
+  "PushCode.pushCode": PushCode.pushCode,
+  "Server.start": Server.start,
+  "UploadZip.uploadZip": UploadZip.uploadZip,
+};

package/src/parts/CommitDate/CommitDate.js

@@ -0,0 +1,15 @@
+import * as Exec from '../Exec/Exec.js'
+import * as Assert from '../Assert/Assert.js'
+
+export const getCommitDate = async (commit) => {
+  Assert.string(commit)
+  const { stdout } = await Exec.exec('git', ['show', '-s', '--format=%ct', commit])
+  const value = parseInt(stdout)
+  if (isNaN(value)) {
+    throw new Error(`Failed to parse date`)
+  }
+  const milliseconds = value * 1000
+  const date = new Date(milliseconds)
+  const isoString = date.toISOString()
+  return isoString
+}

package/src/parts/CommitHash/CommitHash.js

@@ -0,0 +1,15 @@
+import { VError } from "@lvce-editor/verror";
+import * as Exec from "../Exec/Exec.js";
+
+export const getCommitHash = async () => {
+  try {
+    const { stdout } = await Exec.exec("git", [
+      "rev-parse",
+      "--short=7",
+      "HEAD",
+    ]);
+    return stdout;
+  } catch (error) {
+    throw new VError(error, "Failed to get commit hash");
+  }
+};

package/src/parts/CommitMessage/CommitMessage.js

@@ -0,0 +1,14 @@
+import { VError } from "@lvce-editor/verror";
+import * as Exec from "../Exec/Exec.js";
+
+export const getCommitMessage = async () => {
+  try {
+    if (process.env.CI_COMMIT_MESSAGE) {
+      return process.env.CI_COMMIT_MESSAGE;
+    }
+    const { stdout } = await Exec.exec("git", ["log", "-1", "--pretty=%B"]);
+    return stdout.trim();
+  } catch (error) {
+    throw new VError(error, "Failed to get commit message");
+  }
+};

package/src/parts/CompileSass/CompileSass.js

@@ -0,0 +1,12 @@
+import * as SassProcess from "../SassProcess/SassProcess.js";
+
+export const compileSass = async (
+  scssFileName,
+  { updateDynamicResources = true, sourceMap = false } = {}
+) => {
+  return SassProcess.invoke("CompileSass.compileSass", {
+    absolutePath: scssFileName,
+    updateDynamicResources,
+    sourceMap,
+  });
+};

package/src/parts/CompileSassIndividually/CompileSassIndividually.js

@@ -0,0 +1,22 @@
+import * as SassProcess from "../SassProcess/SassProcess.js";
+
+export const compileSassIndividually = async (
+  rootScssFileName,
+  {
+    updateDynamicResources = true,
+    fileName = "",
+    needsFull = true,
+    content = undefined,
+  } = {}
+) => {
+  return SassProcess.invoke(
+    "CompileSass.compileSassIndividually",
+    rootScssFileName,
+    {
+      updateDynamicResources,
+      fileName,
+      needsFull,
+      content,
+    }
+  );
+};

package/src/parts/Config/Config.js

@@ -0,0 +1,36 @@
+import { join } from "path";
+import * as Root from "../Root/Root.js";
+
+export const userEmail = process.env.PRONTO_USER_EMAIL;
+export const userPassword = process.env.PRONTO_USER_PASSWORD;
+// TODO use direct backend url
+export const loginUrl = `https://builder.purplemanager.com/api/user/login`;
+export const listResourcesUrl = `https://purplemanager.com/purple-manager-backend/app/listresources`;
+export const appId = `b745c9ad-2d2e-4515-92a0-d0a2baed181e`;
+export const downloadBaseUrl = `https://purplemanager.com/purple-manager-backend/app/downloadappresources`;
+export const uploadBaseUrl = `https://purplemanager.com/purple-manager-backend/app/uploadresources`;
+export const preview = true;
+export const uploadTimeout = 120000;
+
+export const rootSassFile = join(
+  Root.root,
+  "packages",
+  "daz",
+  "src",
+  "default",
+  "storefront",
+  "assets",
+  "scss",
+  "__index.scss"
+);
+
+export const rootCssFile = join(
+  Root.root,
+  "packages",
+  "daz",
+  "src",
+  "default",
+  "storefront",
+  "assets",
+  "custom.css"
+);

package/src/parts/CreateServer/CreateServer.js

@@ -0,0 +1,22 @@
+import * as http from "node:http";
+import * as ws from "ws";
+import * as App from "../App/App.js";
+import * as Assert from "../Assert/Assert.js";
+import * as ChangeWatcher from "../ChangeWatcher/ChangeWatcher.js";
+import * as FileWatcher from "../FileWatcher/FileWatcher.js";
+import * as HandleFileChange from "../HandleFileChange/HandleFileChange.js";
+
+export const createServer = async (root) => {
+  Assert.string(root);
+  const app = App.create(root);
+  const server = http.createServer(app);
+  const webSocketServer = new ws.WebSocketServer({
+    server,
+  });
+  const handleFileChange = (event) => {
+    HandleFileChange.handleFileChange(webSocketServer.clients, event, root);
+  };
+  FileWatcher.create(root, handleFileChange);
+  ChangeWatcher.create(webSocketServer);
+  return server;
+};

package/src/parts/CreateZip/CreateZip.js

@@ -0,0 +1,8 @@
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+
+export const createZip = ({ inDir, outFile }) => {
+  return NetworkProcess.invoke("Network.createZip", {
+    inDir,
+    outFile,
+  });
+};

package/src/parts/DownloadZipFile/DownloadZipFile.js

@@ -0,0 +1,15 @@
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+
+export const downloadZipFile = ({
+  zipFileId,
+  downloadBaseUrl,
+  sessionId,
+  outFile,
+}) => {
+  return NetworkProcess.invoke("Network.downloadZipFile", {
+    zipFileId,
+    downloadBaseUrl,
+    sessionId,
+    outFile,
+  });
+};

package/src/parts/Exec/Exec.js

@@ -0,0 +1,2 @@
+
+export {execa as exec} from 'execa'

package/src/parts/Exit/Exit.js

@@ -0,0 +1,3 @@
+export const exit = () => {
+  process.exit(0);
+};

package/src/parts/ExtractZip/ExtractZip.js

@@ -0,0 +1,8 @@
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+
+export const extractZip = ({ inFile, outDir }) => {
+  return NetworkProcess.invoke("Network.extractZip", {
+    inFile,
+    outDir,
+  });
+};

package/src/parts/FileWatcher/FileWatcher.js

@@ -0,0 +1,11 @@
+import { watch } from "node:fs/promises";
+import * as Assert from "../Assert/Assert.js";
+
+export const create = async (root, callback) => {
+  Assert.string(root);
+  const watcher = watch(root, { recursive: true });
+  for await (const event of watcher) {
+    callback(event);
+  }
+  return watcher;
+};

package/src/parts/FilesPath/FilesPath.js

@@ -0,0 +1,4 @@
+import { join } from "node:path";
+import * as Root from "../Root/Root.js";
+
+export const filesPath = join(Root.root, "packages", "pronto-files", "files");

package/src/parts/GetCommandFromCliArgs/GetCommandFromCliArgs.js

@@ -0,0 +1,15 @@
+export const getCommandFromCliArgs = (argv) => {
+  if (argv.includes("pull-code") || argv.includes("pull")) {
+    return "PullCode.pullCode";
+  }
+  if (argv.includes("server") || argv.includes("dev")) {
+    return "Server.start";
+  }
+  if (argv.includes("push-code") || argv.includes("push")) {
+    return "PushCode.pushCode";
+  }
+  if (argv.includes("build")) {
+    return "Build.build";
+  }
+  return "";
+};

package/src/parts/GetConfigPath/GetConfigPath.js

@@ -0,0 +1,6 @@
+import { join } from "path";
+import * as Root from "../Root/Root.js";
+
+export const getConfigPath = () => {
+  return join(Root.root, "packages", "daz", "pronto.json");
+};

package/src/parts/GetListContentZipFilesResponse/GetListContentZipFilesResponse.js

@@ -0,0 +1,13 @@
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+
+export const getListContentZipFilesResponse = ({
+  listResourcesUrl,
+  sessionId,
+  appId,
+}) => {
+  return NetworkProcess.invoke("Network.getListContentZipFilesResponse", {
+    listResourcesUrl,
+    sessionId,
+    appId,
+  });
+};

package/src/parts/GetZipUploadMessage/GetZipUploadMessage.js

@@ -0,0 +1,7 @@
+import * as CommitMessage from "../CommitMessage/CommitMessage.js";
+
+export const getZipUploadMessage = async () => {
+  const commitMessage = await CommitMessage.getCommitMessage();
+  const message = `CI ${commitMessage}`;
+  return message;
+};

package/src/parts/HandleFileChange/HandleFileChange.js

@@ -0,0 +1,12 @@
+import { join } from "node:path";
+import * as SendFullUpdates from "../SendFullUpdates/SendFullUpdates.js";
+import * as SendSassUpdates from "../SendSassUpdates/SendSassUpdates.js";
+
+export const handleFileChange = (clients, event, root) => {
+  if (event.filename.endsWith(".scss")) {
+    const absolutePath = join(root, event.filename);
+    SendSassUpdates.sendSassUpdates(clients, absolutePath, undefined);
+  } else {
+    SendFullUpdates.sendFullUpdates(clients);
+  }
+};

package/src/parts/HandleIpc/HandleIpc.js

@@ -0,0 +1,10 @@
+import * as HandleMessage from "../HandleMessage/HandleMessage.js";
+
+export const handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", HandleMessage.handleMessage);
+  } else if ("on" in ipc) {
+    // deprecated
+    ipc.on("message", HandleMessage.handleMessage);
+  }
+};

package/src/parts/HandleMessage/HandleMessage.js

@@ -0,0 +1,27 @@
+import * as Callback from "../Callback/Callback.js";
+import * as Command from "../Command/Command.js";
+import * as JsonRpc from "../JsonRpc/JsonRpc.js";
+
+const prepare = (error) => {
+  return error;
+};
+
+const requiresSocket = (method) => {
+  return false;
+};
+
+const logError = (error, prettyError) => {
+  console.error(error);
+};
+
+export const handleMessage = (event) => {
+  return JsonRpc.handleJsonRpcMessage(
+    event.target,
+    event.data,
+    Command.execute,
+    Callback.resolve,
+    prepare,
+    logError,
+    requiresSocket,
+  );
+};

package/src/parts/IpcParent/IpcParent.js

@@ -0,0 +1,10 @@
+import * as IpcParentModule from '../IpcParentModule/IpcParentModule.js'
+
+export const create = async ({ method, ...options }) => {
+  const module = await IpcParentModule.getModule(method)
+  // @ts-ignore
+  const rawIpc = await module.create(options)
+  // @ts-ignore
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -0,0 +1,16 @@
+import {
+  IpcParentWithNodeForkedProcess,
+  IpcParentWithNodeWorker,
+} from "@lvce-editor/ipc";
+import * as IpcParentType from "../IpcParentType/IpcParentType.js";
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcParentType.NodeWorker:
+      return IpcParentWithNodeWorker;
+    case IpcParentType.NodeForkedProcess:
+      return IpcParentWithNodeForkedProcess;
+    default:
+      throw new Error("unexpected ipc type");
+  }
+};

package/src/parts/IpcParentType/IpcParentType.js

@@ -0,0 +1,3 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2
+export const ElectronUtilityProcess = 3

package/src/parts/JsonRpc/JsonRpc.js

@@ -0,0 +1 @@
+export * from '@lvce-editor/json-rpc'

package/src/parts/LaunchNetworkProcess/LaunchNetworkProcess.js

@@ -0,0 +1,15 @@
+import * as HandleIpc from "../HandleIpc/HandleIpc.js";
+import * as IpcParent from "../IpcParent/IpcParent.js";
+import * as IpcParentType from "../IpcParentType/IpcParentType.js";
+import * as NetworkProcessPath from "../NetworkProcessPath/NetworkProcessPath.js";
+
+export const launchNetworkProcess = async () => {
+  const ipc = await IpcParent.create({
+    method: IpcParentType.NodeForkedProcess,
+    path: NetworkProcessPath.networkProcessPath,
+  });
+  HandleIpc.handleIpc(ipc);
+  // @ts-ignore
+  ipc._rawIpc.unref();
+  return ipc;
+};

package/src/parts/LaunchSassProcess/LaunchSassProcess.js

@@ -0,0 +1,13 @@
+import * as IpcParent from "../IpcParent/IpcParent.js";
+import * as IpcParentType from "../IpcParentType/IpcParentType.js";
+import * as SassProcessPath from "../SassProcessPath/SassProcessPath.js";
+import * as HandleIpc from "../HandleIpc/HandleIpc.js";
+
+export const launchSassProcess = async () => {
+  const ipc = await IpcParent.create({
+    method: IpcParentType.NodeForkedProcess,
+    path: SassProcessPath.sassProcessPath,
+  });
+  HandleIpc.handleIpc(ipc);
+  return ipc;
+};

package/src/parts/ListContentZipFiles/ListContentZipFiles.js

@@ -0,0 +1,18 @@
+import * as GetListContentZipFilesResponse from "../GetListContentZipFilesResponse/GetListContentZipFilesResponse.js";
+import * as ParseListContentZipFilesResponse from "../ParseListContentZipFilesResponse/ParseListContentZipFilesResponse.js";
+
+export const listContentZipFiles = async ({
+  listResourcesUrl,
+  sessionId,
+  appId,
+}) => {
+  const result =
+    await GetListContentZipFilesResponse.getListContentZipFilesResponse({
+      listResourcesUrl,
+      sessionId,
+      appId,
+    });
+  const zips =
+    ParseListContentZipFilesResponse.parseListContentZipFilesResponse(result);
+  return zips;
+};

package/src/parts/LoadConfig/LoadConfig.js

@@ -0,0 +1,7 @@
+import { readFile } from "fs/promises";
+
+export const loadConfig = async (configPath) => {
+  const content = await readFile(configPath, "utf8");
+  const value = JSON.parse(content);
+  return value;
+};

package/src/parts/Login/Login.js

@@ -0,0 +1,14 @@
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+
+/**
+ *
+ * @param {*} param0
+ * @returns {Promise<any>}
+ */
+export const login = async ({ loginUrl, userEmail, userPassword }) => {
+  return NetworkProcess.invoke("Network.login", {
+    loginUrl,
+    userEmail,
+    userPassword,
+  });
+};

package/src/parts/Main/Main.js

@@ -0,0 +1,8 @@
+import * as Command from "../Command/Command.js";
+import * as GetCommandFromCliArgs from "../GetCommandFromCliArgs/GetCommandFromCliArgs.js";
+
+export const main = async () => {
+  const { argv } = process;
+  const command = GetCommandFromCliArgs.getCommandFromCliArgs(argv);
+  await Command.execute(command);
+};

package/src/parts/NetworkProcess/NetworkProcess.js

@@ -0,0 +1,26 @@
+import * as JsonRpc from "../JsonRpc/JsonRpc.js";
+import * as LaunchNetworkProcess from "../LaunchNetworkProcess/LaunchNetworkProcess.js";
+
+const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+};
+
+const getOrCreate = () => {
+  if (!state.ipc) {
+    state.ipc = LaunchNetworkProcess.launchNetworkProcess();
+  }
+  return state.ipc;
+};
+
+export const invoke = async (method, ...params) => {
+  const ipc = await getOrCreate();
+  return JsonRpc.invoke(ipc, method, ...params);
+};
+
+export const dispose = async () => {
+  const ipc = await getOrCreate();
+  ipc.dispose();
+};

package/src/parts/NetworkProcessPath/NetworkProcessPath.js

@@ -0,0 +1,10 @@
+import * as Path from "node:path";
+import * as Root from "../Root/Root.js";
+
+export const networkProcessPath = Path.join(
+  Root.root,
+  "packages",
+  "pronto-network-process",
+  "src",
+  "networkProcessMain.js"
+);

package/src/parts/ParseListContentZipFilesResponse/ParseListContentZipFilesResponse.js

@@ -0,0 +1,11 @@
+export const parseListContentZipFilesResponse = (result) => {
+  const zips = result.result;
+  if (zips.length === 0) {
+    throw new Error("no zips found");
+  }
+  const first = zips[0];
+  return {
+    id: first.id,
+    name: first.filename,
+  };
+};

package/src/parts/Promises/Promises.js

@@ -0,0 +1,19 @@
+export const withResolvers = () => {
+  /**
+   * @type {any}
+   */
+  let _resolve;
+  /**
+   * @type {any}
+   */
+  let _reject;
+  const promise = new Promise((resolve, reject) => {
+    _resolve = resolve;
+    _reject = reject;
+  });
+  return {
+    resolve: _resolve,
+    reject: _reject,
+    promise,
+  };
+};

package/src/parts/PullCode/PullCode.js

@@ -0,0 +1,59 @@
+import { VError } from "@lvce-editor/verror";
+import { rename, rm } from "node:fs/promises";
+import { join } from "node:path";
+import * as Config from "../Config/Config.js";
+import * as DownloadZipFile from "../DownloadZipFile/DownloadZipFile.js";
+import * as ExtractZip from "../ExtractZip/ExtractZip.js";
+import * as GetConfigPath from "../GetConfigPath/GetConfigPath.js";
+import * as ListContentZipFiles from "../ListContentZipFiles/ListContentZipFiles.js";
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+import * as LoadConfig from "../LoadConfig/LoadConfig.js";
+import * as Login from "../Login/Login.js";
+import * as Root from "../Root/Root.js";
+
+export const pullCode = async () => {
+  try {
+    const {
+      userEmail,
+      userPassword,
+      loginUrl,
+      appId,
+      downloadBaseUrl,
+      listResourcesUrl,
+    } = Config;
+    const outFile = join(Root.root, ".tmp", "update.zip");
+    const outDir = join(Root.root, ".tmp", "update");
+    const src = join(Root.root, "packages", "daz", "src");
+    const oldSrc = join(Root.root, ".tmp", "old-src");
+    const configPath = GetConfigPath.getConfigPath();
+    const config = await LoadConfig.loadConfig(configPath);
+    const sessionInfo = await Login.login({
+      loginUrl,
+      userEmail,
+      userPassword,
+    });
+    const sessionId = sessionInfo.sessionID;
+    const zipFile = await ListContentZipFiles.listContentZipFiles({
+      listResourcesUrl,
+      sessionId,
+      appId,
+    });
+    await DownloadZipFile.downloadZipFile({
+      zipFileId: zipFile.id,
+      downloadBaseUrl: downloadBaseUrl,
+      sessionId,
+      outFile,
+    });
+    await ExtractZip.extractZip({
+      inFile: outFile,
+      outDir,
+    });
+    await rm(oldSrc, { recursive: true, force: true });
+    await rename(src, oldSrc);
+    await rename(outDir, src);
+  } catch (error) {
+    throw new VError(error, `Failed to pull code`);
+  } finally {
+    NetworkProcess.dispose();
+  }
+};

package/src/parts/PushCode/PushCode.js

@@ -0,0 +1,58 @@
+import { VError } from "@lvce-editor/verror";
+import { join } from "node:path";
+import * as Config from "../Config/Config.js";
+import * as CreateZip from "../CreateZip/CreateZip.js";
+import * as GetZipUploadMessage from "../GetZipUploadMessage/GetZipUploadMessage.js";
+import * as Login from "../Login/Login.js";
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+import * as Root from "../Root/Root.js";
+import * as UploadZip from "../UploadZip/UploadZip.js";
+
+export const pushCode = async () => {
+  try {
+    const {
+      userEmail,
+      userPassword,
+      loginUrl,
+      appId,
+      uploadBaseUrl,
+      preview,
+      uploadTimeout,
+    } = Config;
+    if (!userEmail) {
+      throw new Error(`missing user email`);
+    }
+    if (!userPassword) {
+      throw new Error("missing user password");
+    }
+    const outFile = join(Root.root, ".tmp", "upload.zip");
+    const src = join(Root.root, "packages", "daz", "src");
+    const sessionInfo = await Login.login({
+      loginUrl,
+      userEmail,
+      userPassword,
+    });
+    const sessionId = sessionInfo.sessionID;
+    const message = await GetZipUploadMessage.getZipUploadMessage();
+
+    await CreateZip.createZip({
+      inDir: src,
+      outFile,
+    });
+    const response = await UploadZip.uploadZip({
+      file: outFile,
+      uploadBaseUrl,
+      preview,
+      appId,
+      sessionId,
+      uploadTimeout,
+      message,
+    });
+
+    console.log({ response });
+  } catch (error) {
+    throw new VError(error, `Failed to push code`);
+  } finally {
+    NetworkProcess.dispose();
+  }
+};

package/src/parts/Root/Root.js

@@ -0,0 +1,6 @@
+import { dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+export const root = `${__dirname}/../../../../..`;

package/src/parts/SassProcess/SassProcess.js

@@ -0,0 +1,26 @@
+import * as LaunchSassProcess from "../LaunchSassProcess/LaunchSassProcess.js";
+import * as JsonRpc from "../JsonRpc/JsonRpc.js";
+
+const state = {
+  /**
+   * @type {any}
+   */
+  ipc: undefined,
+};
+
+const getOrCreate = () => {
+  if (!state.ipc) {
+    state.ipc = LaunchSassProcess.launchSassProcess();
+  }
+  return state.ipc;
+};
+
+export const invoke = async (method, ...params) => {
+  const ipc = await getOrCreate();
+  return JsonRpc.invoke(ipc, method, ...params);
+};
+
+export const dispose = async () => {
+  const ipc = await getOrCreate();
+  ipc.dispose();
+};

package/src/parts/SassProcessPath/SassProcessPath.js

@@ -0,0 +1,10 @@
+import * as Path from "node:path";
+import * as Root from "../Root/Root.js";
+
+export const sassProcessPath = Path.join(
+  Root.root,
+  "packages",
+  "pronto-sass-compiler",
+  "src",
+  "sassCompilerMain.js"
+);

package/src/parts/SendFullUpdates/SendFullUpdates.js

@@ -0,0 +1,9 @@
+import * as SendUpdates from "../SendUpdates/SendUpdates.js";
+
+export const sendFullUpdates = (clients) => {
+  SendUpdates.sendUpdates(clients, {
+    jsonrpc: "2.0",
+    method: "reload",
+    params: [],
+  });
+};

package/src/parts/SendSassUpdates/SendSassUpdates.js

@@ -0,0 +1,50 @@
+import * as CompileSassIndividually from "../CompileSassIndividually/CompileSassIndividually.js";
+import * as Config from "../Config/Config.js";
+import * as SendUpdates from "../SendUpdates/SendUpdates.js";
+
+const incrementalCompileKey = "___incrementalCompile";
+
+const clientNeedsFullCompile = (client) => {
+  return !client[incrementalCompileKey];
+};
+
+const needsFullCompile = (clients) => {
+  for (const client of clients) {
+    if (clientNeedsFullCompile(client)) {
+      return true;
+    }
+  }
+  return false;
+};
+
+export const sendSassUpdates = async (clients, fileName, content) => {
+  try {
+    const needsFull = needsFullCompile(clients);
+    const changes = await CompileSassIndividually.compileSassIndividually(
+      Config.rootSassFile,
+      {
+        updateDynamicResources: true,
+        fileName,
+        needsFull,
+        content,
+      }
+    );
+    if (needsFull) {
+      for (const client of clients) {
+        client[incrementalCompileKey] = true;
+      }
+    }
+    SendUpdates.sendUpdates(clients, {
+      jsonrpc: "2.0",
+      method: "updateCss",
+      params: [changes],
+    });
+  } catch (error) {
+    console.warn(error);
+    SendUpdates.sendUpdates(clients, {
+      jsonrpc: "2.0",
+      method: "updateCssError",
+      params: [`${error}`],
+    });
+  }
+};

package/src/parts/SendUpdates/SendUpdates.js

@@ -0,0 +1,7 @@
+export const sendUpdates = (clients, message) => {
+  const sendClientUpdate = (client) => {
+    client.send(JSON.stringify(message));
+  };
+
+  clients.forEach(sendClientUpdate);
+};

package/src/parts/Server/Server.js

@@ -0,0 +1,10 @@
+import * as CreateServer from "../CreateServer/CreateServer.js";
+import * as Promises from "../Promises/Promises.js";
+
+export const start = async (root = process.cwd(), port = 3000) => {
+  const server = await CreateServer.createServer(root);
+  const { resolve, promise } = Promises.withResolvers();
+  server.listen(port, resolve);
+  await promise;
+  console.info(`[server] listening on http://localhost:${port}`);
+};

package/src/parts/UpdateCss/UpdateCss.js

@@ -0,0 +1,17 @@
+const occurrenceSnippet = "resource://dynamic";
+const replacementSnippet = ``;
+
+export const updateCss = (content) => {
+  return content.replaceAll(occurrenceSnippet, replacementSnippet);
+};
+
+const reverseOccurrenceSnippet = "../../images";
+
+const reverseReplacementSnippet = "resource://dynamic/storefront/images";
+
+export const reverseUpdateCss = (content) => {
+  return content.replaceAll(
+    reverseOccurrenceSnippet,
+    reverseReplacementSnippet
+  );
+};

package/src/parts/UpdateIndexHtml/UpdateIndexHtml.js

@@ -0,0 +1,24 @@
+const occurrenceSnippetBody = "</body>";
+const replacementSnippetBody = `
+      <script>
+        window._editorAppInfo = {
+          appId: "b745c9ad-2d2e-4515-92a0-d0a2baed181e",
+          baseUrl: "https://purplemanager.com/delivery",
+          contentUrl: "https://catalog.purplemanager.com",
+          forcePurpleImplUsage: true
+        };
+        </script>
+        <script type="module" src="/assets/preview-inject-bundle.js"></script>
+        <script type="module" src="/assets/live-reload.js"></script>
+      </body>`;
+
+const occurrenceSnippetHead = "</head>";
+const replacementSnippetHead = `
+    <link rel="stylesheet" href="/theme.css" />
+    </head>`;
+
+export const updateIndexHtml = (content) => {
+  return content
+    .replace(occurrenceSnippetBody, replacementSnippetBody)
+    .replace(occurrenceSnippetHead, replacementSnippetHead);
+};

package/src/parts/UploadZip/UploadZip.js

@@ -0,0 +1,21 @@
+import * as NetworkProcess from "../NetworkProcess/NetworkProcess.js";
+
+export const uploadZip = ({
+  file,
+  uploadBaseUrl,
+  preview,
+  appId,
+  sessionId,
+  uploadTimeout,
+  message,
+}) => {
+  return NetworkProcess.invoke("Network.uploadZip", {
+    file,
+    uploadBaseUrl,
+    preview,
+    appId,
+    sessionId,
+    uploadTimeout,
+    message,
+  });
+};

package/src/parts/VError/VError.js

@@ -0,0 +1 @@
+export * from "@lvce-editor/verror";