fullstacked 0.12.0-1175 → 0.12.0-1186

package/fullstacked_modules/ai/index.ts

@@ -0,0 +1,14 @@
+import * as aiAgent from "@fullstacked/ai-agent";
+import { z as zod } from "zod";
+export * from "./tools/fs"; 
+import { createToolFS } from "./tools/fs";
+
+export * from "@fullstacked/ai-agent";
+
+export const z = zod;
+
+export default {
+    ...aiAgent,
+    createToolFS,
+    z: zod
+};

package/fullstacked_modules/ai/package.json

@@ -0,0 +1,5 @@
+{
+    "main": "./index.js",
+    "name": "ai",
+    "version": "0.0.0"
+}

package/fullstacked_modules/ai/tools/fs.ts

@@ -0,0 +1,60 @@
+import { createTool } from "@fullstacked/ai-agent";
+import { z } from "zod";
+import type fsType from "../../fs";
+import _fs from "fs";
+
+const fs: typeof fsType = _fs;
+
+type ToolFSOptions = {
+    baseDirectory: string
+}
+
+export function createToolFS(opts?: Partial<ToolFSOptions>) {
+    let basePath = opts?.baseDirectory || "";
+
+    if(basePath !== "" && !basePath.endsWith("/")) {
+        basePath += "/";
+    }
+
+    const fixPath = (path: string) => basePath + path;
+
+    return [
+        createTool({
+            name: "CreateDir",
+            description: "Create a directory.",
+            schema: z.object({
+                path: z.string()
+            }),
+            fn: ({ path }) => fs.mkdir(fixPath(path)),
+            message: ({ path }) => `Creating directory \`${path}\``
+        }),
+        createTool({
+            name: "ListFiles",
+            description: "List files in a directory.",
+            schema: z.object({
+                path: z.string()
+            }),
+            fn: ({ path }) => fs.readdir(fixPath(path)),
+            message: ({ path }) => `Listing files at \`${path}\``
+        }),
+        createTool({
+            name: "ReadFile",
+            description: "Read the content of a file.",
+            schema: z.object({
+                path: z.string()
+            }),
+            fn: ({ path }) => fs.readFile(fixPath(path), { encoding: "utf8" }),
+            message: ({ path }) => `Reading file at \`${path}\``
+        }),
+        createTool({
+            name: "WriteFile",
+            description: "Write content to file.",
+            schema: z.object({
+                path: z.string(),
+                contents: z.string()
+            }),
+            fn: ({ path, contents }) => fs.writeFile(fixPath(path), contents),
+            message: ({ path }) => `Writing to \`${path}\``
+        })
+    ];
+}

package/fullstacked_modules/archive/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "archive" {}

package/fullstacked_modules/bridge/index.ts

@@ -0,0 +1,120 @@
+import "../core_message";
+import platform, { Platform } from "../platform";
+import { BridgeAndroid } from "./platform/android";
+import { BridgeApple, initRespondApple } from "./platform/apple";
+import { BridgeLinuxGTK, initRespondLinuxGTK } from "./platform/linux-gtk";
+import { BridgeLinuxQT, initRespondLinuxQT } from "./platform/linux-qt";
+import { BridgeElectron } from "./platform/electron";
+import { BridgeNode, initCallbackNode } from "./platform/node";
+import { BridgeWasm } from "./platform/wasm";
+import { BridgeWindows, initRespondWindows } from "./platform/windows";
+import git from "../git";
+import esbuild from "../esbuild";
+import { SnackBar } from "../components/snackbar";
+import { Button } from "@fullstacked/ui";
+import { serializeArgs } from "./serialization";
+import { buildSASS } from "../esbuild/sass";
+import fs from "../fs";
+
+export type Bridge = (
+    payload: Uint8Array,
+    transformer?: (args: any) => any
+) => Promise<any>;
+
+export let bridge: Bridge;
+switch (platform) {
+    case Platform.NODE:
+        bridge = BridgeNode;
+        initCallbackNode();
+        break;
+    case Platform.APPLE:
+        bridge = BridgeApple;
+        initRespondApple();
+        break;
+    case Platform.ANDROID:
+        bridge = BridgeAndroid;
+        break;
+    case Platform.WASM:
+        bridge = BridgeWasm;
+        break;
+    case Platform.WINDOWS:
+        bridge = BridgeWindows;
+        initRespondWindows();
+        break;
+    case Platform.LINUX_GTK:
+        bridge = BridgeLinuxGTK;
+        initRespondLinuxGTK();
+        break;
+    case Platform.LINUX_QT:
+        bridge = BridgeLinuxQT;
+        initRespondLinuxQT();
+        break;
+    case Platform.ELECTRON:
+        bridge = BridgeElectron;
+        break;
+    case Platform.DOCKER:
+        console.log("Bridge not yet implemented");
+}
+
+console.log("FullStacked");
+bridge(new Uint8Array([0]));
+
+let lastUpdateCheck = 0;
+const updateCheckDelay = 1000 * 10 // 10sec;
+async function checkForUpdates() {
+    window.requestAnimationFrame(checkForUpdates)
+
+    const now = Date.now();
+    if (now - lastUpdateCheck < updateCheckDelay) {
+        return;
+    }
+
+    lastUpdateCheck = now;
+
+    if (await git.pull() !== git.PullResponse.DID_PULL) {
+        return;
+    }
+
+    let preventReload = false;
+    const preventReloadButton = Button({
+        text: "Stop"
+    });
+    preventReloadButton.onclick = () => {
+        preventReload = true;
+        snackbar.dismiss();
+    }
+
+    const snackbar = SnackBar({
+        message: "Project has updated. Rebuilding...",
+        button: preventReloadButton
+    });
+
+    buildSASS(fs)
+        .then(() => {
+            esbuild.build().then(() => {
+                snackbar.dismiss();
+                if (preventReload) return;
+                window.location.reload();
+            });
+        });
+
+}
+if (await git.hasGit()) {
+    checkForUpdates();
+}
+
+// 40
+function setTitle(title: string) {
+    const payload = new Uint8Array([40, ...serializeArgs([title])]);
+    bridge(payload);
+}
+
+let lastTitleSeen = null;
+setInterval(() => {
+    if (!document.title) return;
+
+    if (lastTitleSeen !== document.title) {
+        setTitle(document.title);
+    }
+    lastTitleSeen = document.title;
+}, 500);

package/{lib → fullstacked_modules}/bridge/platform/node.ts

@@ -4,7 +4,7 @@ import { deserializeArgs } from "../serialization";
 const bridge = globalThis.fetch;
 
 export const BridgeNode: Bridge = async (
-    payload: Uint8Array,
+    payload: Uint8Array<ArrayBuffer>,
     transformer?: (responseArgs: any[]) => any
 ) => {
     const response = await bridge("/call", {

package/fullstacked_modules/config/config.ts

@@ -0,0 +1,33 @@
+import { CONFIG_DATA_TYPE, CONFIG_TYPE } from "../../editor/types";
+import { bridge } from "../bridge";
+import { serializeArgs } from "../bridge/serialization";
+
+
+export function get<T extends CONFIG_TYPE>(
+    configType: T,
+    checkExists: boolean = false
+): Promise<CONFIG_DATA_TYPE[T]> {
+    const payload = new Uint8Array([50, ...serializeArgs([configType])]);
+
+    const transformer = ([string]) => {
+        if (!string) {
+            return checkExists ? null : {};
+        }
+
+        return JSON.parse(string);
+    };
+
+    return bridge(payload, transformer);
+}
+
+export function save<T extends CONFIG_TYPE>(
+    configType: T,
+    configData: CONFIG_DATA_TYPE[T]
+): Promise<boolean> {
+    const payload = new Uint8Array([
+        51,
+        ...serializeArgs([configType, JSON.stringify(configData)])
+    ]);
+
+    return bridge(payload, ([success]) => success);
+}

package/fullstacked_modules/config/index.ts

@@ -0,0 +1,3 @@
+import * as config from "./config";
+export default config;
+export * from "./config";

package/fullstacked_modules/connect/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "connect" {}

package/{lib → fullstacked_modules}/core_message/core_message.ts

@@ -1,5 +1,3 @@
-import { bridge } from "../bridge";
-import { serializeArgs } from "../bridge/serialization";
 import { SnackBar } from "../components/snackbar";
 
 const coreMessageListeners = new Map<string, Set<(message: string) => void>>();
@@ -57,20 +55,3 @@ addListener("alert", (message) => {
         autoDismissTimeout: 4000
     });
 });
-
-// 40
-function setTitle(title: string) {
-    const payload = new Uint8Array([
-        40,
-        ...serializeArgs([title])
-    ]);
-    bridge(payload);
-}
-
-let lastTitleSeen = null;
-setInterval(() => {
-    if(lastTitleSeen !== document.title) {
-        setTitle(document.title);
-    }
-    lastTitleSeen = document.title;
-}, 500)

package/fullstacked_modules/core_open.ts

@@ -0,0 +1,9 @@
+import { bridge } from "./bridge";
+import { serializeArgs } from "./bridge/serialization";
+
+// 100
+export default function core_open(projectId: string) {
+    const payload = new Uint8Array([100, ...serializeArgs([projectId])]);
+
+    return bridge(payload);
+}

package/fullstacked_modules/esbuild/esbuild.ts

@@ -0,0 +1,101 @@
+import { Project } from "../../editor/types";
+import { toByteArray } from "../base64";
+import { bridge } from "../bridge";
+import {
+    deserializeArgs,
+    getLowestKeyIdAvailable,
+    serializeArgs
+} from "../bridge/serialization";
+import type { Message } from "esbuild";
+import core_message from "../core_message";
+
+// 55
+export function version(): Promise<string> {
+    const payload = new Uint8Array([55]);
+    return bridge(payload, ([str]) => str);
+}
+
+let addedListener = false;
+const activeBuilds = new Map<
+    number,
+    { project: Project; resolve: (buildErrors: Message[]) => void }
+>();
+
+function buildResponse(buildResult: string) {
+    const responseData = toByteArray(buildResult);
+    const [id, errorsStr] = deserializeArgs(responseData);
+    const activeBuild = activeBuilds.get(id);
+
+    if (!errorsStr) {
+        activeBuild.resolve([]);
+    } else {
+        const errors = JSON.parse(errorsStr);
+        const messages = errors?.map(uncapitalizeKeys).map((error) => ({
+            ...error,
+            location: error.location
+                ? {
+                      ...error.location,
+                      file: error.location.file.includes(activeBuild.project.id)
+                          ? activeBuild.project.id +
+                            error.location.file
+                                .split(activeBuild.project.id)
+                                .pop()
+                          : error.location.file
+                  }
+                : null
+        }));
+        activeBuild.resolve(messages);
+    }
+
+    activeBuilds.delete(id);
+}
+
+// 56
+export function build(project?: Project): Promise<Message[]> {
+    if (!addedListener) {
+        core_message.addListener("build", buildResponse);
+        addedListener = true;
+    }
+
+
+    const args: any[] = project
+        ? [project.id]
+        : []
+
+    const buildId = getLowestKeyIdAvailable(activeBuilds);
+    args.push(buildId)
+
+    const payload = new Uint8Array([
+        56,
+        ...serializeArgs(args)
+    ]);
+
+    return new Promise((resolve) => {
+        activeBuilds.set(buildId, {
+            project,
+            resolve
+        });
+        bridge(payload);
+    });
+}
+
+// 57
+export function shouldBuild(project: Project): Promise<boolean> {
+    const payload = new Uint8Array([57, ...serializeArgs([project.id])]);
+
+    return bridge(payload, ([should]) => should);
+}
+
+function isPlainObject(input: any) {
+    return input && !Array.isArray(input) && typeof input === "object";
+}
+
+function uncapitalizeKeys<T>(obj: T) {
+    const final = {};
+    for (const [key, value] of Object.entries(obj)) {
+        final[key.at(0).toLowerCase() + key.slice(1)] = isPlainObject(value)
+            ? uncapitalizeKeys(value)
+            : value;
+    }
+    return final as T;
+}

package/fullstacked_modules/esbuild/index.ts

@@ -0,0 +1,3 @@
+import * as esbuild from "./esbuild";
+export default esbuild;
+export * from "./esbuild";

package/fullstacked_modules/esbuild/sass.ts

@@ -0,0 +1,103 @@
+import * as sass from "sass";
+import type { Message } from "esbuild";
+import { Project } from "../../editor/types";
+
+export async function buildSASS(
+    fs: {
+        mkdir(dir: string): Promise<boolean>;
+        writeFile(path: string, data: string): Promise<boolean>;
+        readdir(dir: string): Promise<string[]>;
+        readFile(path: string, options: any): Promise<string>;
+    },
+    project?: Project
+): Promise<Partial<Message>> {
+    const baseDirectory = project?.id || "";
+
+    const writeOutputCSS = async (css: string) => {
+        const buildDirectory = baseDirectory
+            ? `${baseDirectory}/.build`
+            : ".build";
+        await fs.mkdir(buildDirectory);
+        console.log(buildDirectory + "/index.css", css)
+        await fs.writeFile(buildDirectory + "/index.css", css);
+    };
+
+    const contents = await fs.readdir(baseDirectory);
+    const entryPointSASS = contents.find(
+        (item) => item === "index.sass" || item === "index.scss"
+    );
+
+    console.log(entryPointSASS)
+
+    // check for css file and write to output
+    // esbuild will pick it up and merge with css in js
+    if (!entryPointSASS) {
+        const entryPointCSS = contents.find((item) => item === "index.css");
+        if (entryPointCSS) {
+            const filePath = baseDirectory
+                ? `${baseDirectory}/${entryPointCSS}`
+                : entryPointCSS;
+            // TODO: fs.copyFile
+            await writeOutputCSS(
+                await fs.readFile(filePath, {
+                    encoding: "utf8"
+                })
+            );
+        } else {
+            await writeOutputCSS("");
+        }
+
+        return;
+    }
+
+    const filePath = baseDirectory
+        ? `${baseDirectory}/${entryPointSASS}`
+        : entryPointSASS;
+    const entryData = await fs.readFile(filePath, {
+        encoding: "utf8"
+    });
+    let result: sass.CompileResult;
+    try {
+        result = await sass.compileStringAsync(entryData, {
+            importer: {
+                load: async (url) => {
+                    const filePath = `${baseDirectory}${url.pathname}`;
+                    const contents = await fs.readFile(filePath, {
+                        encoding: "utf8"
+                    });
+                    return {
+                        syntax: filePath.endsWith(".sass")
+                            ? "indented"
+                            : filePath.endsWith(".scss")
+                                ? "scss"
+                                : "css",
+                        contents
+                    };
+                },
+                canonicalize: (path) => new URL(path, window.location.href)
+            }
+        });
+    } catch (e) {
+        const error = e as unknown as sass.Exception;
+        const file =
+            baseDirectory + (error.span.url?.pathname || "/" + entryPointSASS);
+        const line = error.span.start.line + 1;
+        const column = error.span.start.column;
+        const length = error.span.text.length;
+        return {
+            text: error.message,
+            location: {
+                file,
+                line,
+                column,
+                length,
+                namespace: "SASS",
+                lineText: error.message,
+                suggestion: ""
+            }
+        };
+    }
+
+    await writeOutputCSS(result.css);
+    return null;
+}

package/fullstacked_modules/fetch/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "fetch" {}

package/{lib → fullstacked_modules}/fetch/index.ts

@@ -9,6 +9,20 @@ import core_message from "../core_message";
 
 const te = new TextEncoder();
 
+type FetchOptions = {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    headers: Record<string, string>;
+    body: string | Uint8Array;
+    timeout: number;
+    stream: boolean;
+};
+
+type FetchResponse = {
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+};
+
 type ResponseSimplified = {
     statusCode: number;
     statusMessage: string;

package/fullstacked_modules/fs/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "fs" {}