wao 0.41.3 → 0.41.5

package/{cjs/workspace/frontend → src/workspace/dashboard}/vite.config.js

@@ -3,4 +3,10 @@ import react from "@vitejs/plugin-react"
 
 export default defineConfig({
   plugins: [react()],
+  server: {
+    port: 5174,
+    proxy: {
+      "/api": { target: "http://localhost:3333", changeOrigin: true },
+    },
+  },
 })

package/src/workspace/package.json

@@ -0,0 +1,18 @@
+{
+  "name": "wao-workspace",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "test": "node --test --test-concurrency=1",
+    "test-only": "node --test-only --test-concurrency=1",
+    "test-all": "node --test --test-concurrency=1 test/**/*.test.js",
+    "start": "trap 'kill $(jobs -p)' EXIT; node dashboard/server.js & cd dashboard && npx vite",
+    "start:api": "node dashboard/server.js",
+    "keygen": "node scripts/keygen.js",
+    "deploy": "node scripts/deploy.js"
+  },
+  "dependencies": {
+    "hbsig": "0.3.1",
+    "wao": "0.41.3"
+  }
+}

package/src/workspace/src/counter.lua

@@ -0,0 +1,14 @@
+local count = 0
+
+Handlers.add("Inc", "Inc", function (msg)
+  count = count + 1
+  msg.reply({ Data = "Incremented!" })
+end)
+
+Handlers.add("Get", "Get", function (msg)
+  msg.reply({ Data = tostring(count) })
+end)
+
+Handlers.add("Hello", "Hello", function (msg)
+  msg.reply({ Data = "Hello, World!" })
+end)

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "dist",
+    "declaration": true,
+    "declarationDir": "types",
+    "sourceMap": true,
+    "rootDir": "src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "test"]
+} 

package/types/index.d.ts

@@ -0,0 +1,329 @@
+// Core Types
+export interface JWK {
+    kty: string;
+    e: string;
+    n: string;
+    d?: string;
+    p?: string;
+    q?: string;
+    dp?: string;
+    dq?: string;
+    qi?: string;
+}
+
+export interface Tag {
+    name: string;
+    value: string;
+}
+
+export interface Message {
+    process: string;
+    tags: Tag[];
+    data?: string | Uint8Array;
+    signer?: JWK;
+}
+
+export interface ProcessOptions {
+    boot?: boolean;
+    module?: string;
+    scheduler?: string;
+    memory?: number;
+    jwk?: JWK;
+    tags?: Record<string, string>;
+    data?: string | Uint8Array;
+    auth?: string;
+}
+
+export interface ResultOptions {
+    jwk?: JWK;
+    pid?: string;
+    mid?: string;
+    check?: any[];
+    get?: boolean | string;
+    timeout?: number;
+    mode?: 'aoconnect' | 'local';
+    limit?: number;
+}
+
+export interface DeployOptions {
+    boot?: boolean;
+    loads?: any[];
+    src?: string;
+    src_data?: string;
+    fills?: Record<string, any>;
+    module?: string;
+    scheduler?: string;
+    jwk?: JWK;
+    tags?: Record<string, string>;
+    data?: string | Uint8Array;
+}
+
+// AO Class Types
+export interface AOOptions {
+    module?: string;
+    scheduler?: string;
+    memory?: number;
+    ar?: {
+        host?: string;
+        port?: number;
+        protocol?: string;
+    };
+}
+
+export interface PipeOptions {
+    jwk: JWK;
+    fns: Function[];
+    cb?: Function;
+}
+
+// WeaveDB Types
+export interface WeaveDBOptions {
+    cacheSize?: number;
+    chunkSize?: number;
+    notifySize?: number;
+}
+
+export interface WeaveDBCollection {
+    create: (id: string) => Promise<void>;
+    createData: (col: string, doc: any, val: any) => Promise<void>;
+    open: (filename: string, val: any) => Promise<void>;
+    read: (fd: number, raw_dst_ptr: number, raw_length: number, val: any) => Promise<void>;
+    close: (fd: number) => void;
+}
+
+// WeaveDrive Types
+export interface WeaveDriveOptions {
+    cacheSize?: number;
+    chunkSize?: number;
+    streamChunk?: number;
+}
+
+export interface WeaveDriveFile {
+    reset: (fd: number) => void;
+    create: (id: string) => Promise<number>;
+    read: (fd: number, raw_dst_ptr: number, raw_length: number) => Promise<number>;
+    close: (fd: number) => void;
+}
+
+// Process Class Types
+export interface ProcessOptions {
+    pid: string;
+    ao: AO;
+}
+
+// AR Types
+export interface AROptions {
+    host?: string;
+    port?: number;
+    protocol?: string;
+}
+
+export interface ARTransaction {
+    id: string;
+    anchor?: string;
+    signature?: string;
+    recipient?: string;
+    owner?: {
+        address: string;
+        key: string;
+    };
+    fee?: {
+        winston: string;
+        ar: string;
+    };
+    quantity?: {
+        winston: string;
+        ar: string;
+    };
+    data?: {
+        size: string;
+        type: string;
+    };
+    tags?: Tag[];
+    block?: {
+        id: string;
+        timestamp: number;
+        height: number;
+        previous: string;
+    };
+    parent?: {
+        id: string;
+    };
+    bundledIn?: {
+        id: string;
+    };
+}
+
+// GQL Types
+export interface GQLOptions {
+    url?: string;
+}
+
+export interface GQLQueryOptions {
+    first?: number;
+    after?: string;
+    asc?: boolean;
+    next?: boolean;
+    block?: {
+        min?: number;
+        max?: number;
+    } | [number, number];
+    id?: string;
+    ids?: string[];
+    recipient?: string;
+    recipients?: string[];
+    owner?: string;
+    owners?: string[];
+    tags?: Record<string, string>;
+    fields?: string[] | Record<string, any>;
+}
+
+// HB (HyperBEAM) Types
+export interface HBOptions {
+    url: string;
+}
+
+export interface HBMessage {
+    target: string;
+    from?: string;
+    to?: string;
+}
+
+export interface HBResult {
+    Messages: any[];
+    Spawns: any[];
+    Assignments: any[];
+    Output: any;
+}
+
+// Main Classes
+export class AO {
+    constructor(opt?: AOOptions);
+    init(jwk: JWK): Promise<AO>;
+    toSigner(wallet: JWK): Function;
+    pipe(options: PipeOptions): Promise<any>;
+    postModule(options: { data: string | Uint8Array, jwk: JWK, tags?: Record<string, string>, overwrite?: boolean }): Promise<string>;
+    postScheduler(options: { jwk: JWK, url: string, tags?: Record<string, string>, overwrite?: boolean }): Promise<string>;
+    spwn(options?: ProcessOptions): Promise<string>;
+    res(options?: ResultOptions): Promise<any>;
+    msg(options: Message): Promise<any>;
+    asgn(options: { pid: string, mid: string, jwk: JWK, check?: any[], get?: boolean | string }): Promise<any>;
+    dry(options: { pid: string, jwk: JWK, data?: string | Uint8Array, act?: string, tags?: Tag[], check?: any[], get?: boolean | string }): Promise<any>;
+    ress(options: { pid: string, limit?: number, asc?: boolean, cursor?: string }): Promise<any>;
+    eval(options: { pid: string, jwk: JWK, data: string | Uint8Array }): Promise<any>;
+    transform(options: { src: string, data: any, fills: Record<string, any> }): Promise<string>;
+    load(options: { src: string, data: any, fills: Record<string, any>, pid: string, jwk: JWK }): Promise<any>;
+    wait(options: { pid: string, attempts?: number }): Promise<void>;
+    attest(options: { id: string, jwk: JWK, tags: Tag[] }): Promise<any>;
+    avail(options: { ids: string[], jwk: JWK, tags: Tag[] }): Promise<any>;
+    deploy(options: DeployOptions): Promise<{ p: Process }>;
+    var(options: { pid: string, data: any, json?: boolean, pretty?: boolean }): Promise<any>;
+    p(pid: string): Process;
+    ar: AR;
+}
+
+export class WeaveDB {
+    constructor(ar: any, dir: string, options?: WeaveDBOptions);
+    create(id: string): Promise<void>;
+    createData(col: string, doc: any, val: any): Promise<void>;
+    open(filename: string, val: any): Promise<void>;
+    read(fd: number, raw_dst_ptr: number, raw_length: number, val: any): Promise<void>;
+    close(fd: number): void;
+}
+
+export class WeaveDrive {
+    constructor(ar: any, options?: WeaveDriveOptions);
+    reset(fd: number): void;
+    create(id: string): Promise<number>;
+    read(fd: number, raw_dst_ptr: number, raw_length: number): Promise<number>;
+    close(fd: number): void;
+}
+
+export class Process {
+    constructor(pid: string, ao: AO);
+    load(opt?: any): Promise<any>;
+    msg(act: string, tags: Tag[], opts?: any): Promise<any>;
+    dry(act: string, tags: Tag[], opts?: any): Promise<any>;
+    res(opts?: any): Promise<any>;
+    o(name: string, opt?: any): Promise<any>;
+    m(...opt: any[]): Promise<any>;
+    d(...opt: any[]): Promise<any>;
+    v(data: any, json?: boolean, pretty?: boolean): Promise<any>;
+    r(...opt: any[]): Promise<any>;
+}
+
+export class AR {
+    constructor(options?: AROptions);
+    init(jwk: JWK): Promise<AR>;
+    gen(amount?: string): Promise<{ jwk: JWK, addr: string, pub: string, balance: string }>;
+    toAddr(jwk: JWK): Promise<string>;
+    mine(): Promise<void>;
+    balance(addr?: string): Promise<string>;
+    toAR(winston: string): string;
+    toWinston(ar: string): string;
+    transfer(amount: string, to: string, jwk?: JWK): Promise<{ id: string }>;
+    checkWallet(options?: { jwk?: JWK }): Promise<{ err: any, jwk: JWK }>;
+    post(options: { data: string | Uint8Array, tags?: Record<string, string>, jwk?: JWK }): Promise<{ err: any, id: string }>;
+    tx(txid: string): Promise<ARTransaction>;
+    data(txid: string, asString?: boolean): Promise<string | Uint8Array>;
+    bundle(dataitems: Array<[string | Uint8Array, Record<string, string>]>): Promise<{ err: any, id: string }>;
+    gql: GQL;
+}
+
+export class GQL {
+    constructor(options?: GQLOptions);
+    txs(options?: GQLQueryOptions): Promise<{ next?: () => Promise<any>, data: ARTransaction[] }>;
+    blocks(options?: GQLQueryOptions): Promise<{ next?: () => Promise<any>, data: any[] }>;
+}
+
+export class HB {
+    constructor(options: HBOptions);
+    init(jwk: JWK): Promise<HB>;
+    metrics(): Promise<any>;
+    info(): Promise<any>;
+    messages(options: HBMessage): Promise<any>;
+    process(options?: { tags?: Tag[], data?: string }): Promise<string>;
+    schedule(options: { process: string, tags?: Tag[], data?: string, action?: string }): Promise<number>;
+    compute(options: { process: string, slot: number }): Promise<HBResult>;
+    dryrun(options: { process: string, tags?: Tag[], data?: string, action?: string }): Promise<HBResult>;
+    get(options: { device: string, path: string }): Promise<any>;
+    post(options: { device: string, path: string, tags?: Tag[] }): Promise<any>;
+    request(options: { device: string, path: string, tags?: Tag[], method: string }): Promise<any>;
+}
+
+// Utility Types
+export interface Utils {
+    allChecked: Function;
+    searchTag: Function;
+    checkTag: Function;
+    wait: Function;
+    isLocalhost: Function;
+    tag: Function;
+    ltags: Function;
+    action: Function;
+    isData: Function;
+    getTagVal: Function;
+    srcs: Function;
+    buildTags: Function;
+    isRegExp: Function;
+    mergeChecks: Function;
+    isCheckComplete: Function;
+}
+
+// Test Types
+export interface TestAccount {
+    jwk: JWK;
+    addr: string;
+    signer: Function;
+}
+
+export interface TestConnect {
+    spawn: Function;
+    message: Function;
+    dryrun: Function;
+    assign: Function;
+    result: Function;
+}
+
+export function connect(mem?: any): TestConnect;
+export const acc: TestAccount[]; 

package/waollama/.eslintrc.json

@@ -0,0 +1,3 @@
+{
+  "extends": "next/core-web-vitals"
+}

package/waollama/README.md

@@ -0,0 +1,19 @@
+# WaoLlama
+
+WaoLlama is a fully decentralized onchain LLM agent embedded in the browser on WAO.
+
+```bash
+cd waollama && yarn
+```
+
+It uses the wasm64 module from [aos-llama](https://github.com/samcamwilliams/aos-llama), so you need to enable `Experimental WebAssembly` from [chrome://flags](chrome://flags) to run it in the browser, if you are on Google Chrome.
+
+Also, create `public/llama` directory, and download a gguf file from [Hugging Face](https://huggingface.co/TinyLlama/TinyLlama-1.1B-Chat-v1.0/tree/main), and put into the directory with the name `tynyllama.gguf`, and copy `src/lua/llama.wasm` into the directory. These files are not included due to their huge sizes.
+
+Once everything is set, run the following.
+
+```bash
+yarn dev
+```
+
+Now your app is running at [localhost:3000](http://localhost:3000).

package/waollama/arweave.mjs

@@ -0,0 +1,87 @@
+import {
+  rmdirSync,
+  unlinkSync,
+  writeFileSync,
+  readFileSync,
+  readdirSync,
+} from "fs"
+
+import { resolve, extname } from "path"
+import * as cheerio from "cheerio"
+
+const out = resolve(import.meta.dirname, "out")
+const dirs = readdirSync(out, { withFileTypes: true, recursive: true })
+
+const prefixWithPath = url => {
+  const cleanedUrl = url.replace(/^\.\//, "").replace(/^\//, "")
+  const txt = "${path}" + cleanedUrl
+  return "`" + txt + "`"
+}
+
+const isRelativeUrl = url => !/^https?:\/\//i.test(url)
+
+let _dirs = []
+
+for (const v of dirs) {
+  const ext = extname(v.name)
+  const htmlPath = resolve(v.path, v.name)
+  if (v.isFile() && ext === ".html") {
+    if (v.name !== "index.html") {
+      unlinkSync(htmlPath)
+    } else {
+      const txt = readFileSync(htmlPath, "utf8")
+      const $ = cheerio.load(txt)
+      let _tags = []
+      $("link[href]").each((i, elem) => {
+        const href = $(elem).attr("href")
+        if (isRelativeUrl(href)) {
+          const props = { ...elem.attribs }
+          props.href = prefixWithPath(href)
+          _tags.push({ elm: "link", props })
+          $(elem).remove()
+        }
+      })
+
+      $("script[src]").each((i, elem) => {
+        const src = $(elem).attr("src")
+        if (isRelativeUrl(src)) {
+          const props = { ...elem.attribs }
+          props.src = prefixWithPath(src)
+          _tags.push({ elm: "script", props })
+          $(elem).remove()
+        }
+      })
+
+      $("script").each((i, elem) => {
+        const scriptContent = $(elem).html()
+        if (scriptContent && scriptContent.includes("let tags = []")) {
+          const tagsString = JSON.stringify(_tags)
+          const updatedScriptContent = scriptContent
+            .replace(/let\s+tags\s*=\s*\[\s*\]/, `let tags = ${tagsString}`)
+            .replace(/"`/g, "`")
+            .replace(/`"/g, "`")
+          $(elem).html(updatedScriptContent)
+        }
+      })
+      const modifiedHtml = $.root().html()
+      writeFileSync(htmlPath, modifiedHtml)
+    }
+  } else if (v.isFile() && ext === ".js" && /^webpack/.test(v.name)) {
+    const txt = readFileSync(htmlPath, "utf8")
+    const x = txt.match(/(.)\.p="\/_next\/"/)[1]
+    const mod = txt.replace(
+      new RegExp(`o=${x}\.p`, "g"),
+      `o=_assetPath()+${x}.p`,
+    )
+    writeFileSync(htmlPath, mod)
+  }
+}
+
+const dirs2 = readdirSync(out, { withFileTypes: true })
+for (const v of dirs2) {
+  const htmlPath = resolve(v.path, v.name)
+  console.log(htmlPath)
+  if (v.isDirectory() && v.name !== "_next") {
+    rmdirSync(htmlPath, { recursive: true, force: true })
+  }
+}

package/waollama/components/ui/avatar.jsx

@@ -0,0 +1,49 @@
+'use client'
+
+import { Avatar as ChakraAvatar, Group } from '@chakra-ui/react'
+import * as React from 'react'
+
+export const Avatar = React.forwardRef(function Avatar(props, ref) {
+  const { name, src, srcSet, loading, icon, fallback, children, ...rest } =
+    props
+  return (
+    <ChakraAvatar.Root ref={ref} {...rest}>
+      <AvatarFallback name={name} icon={icon}>
+        {fallback}
+      </AvatarFallback>
+      <ChakraAvatar.Image src={src} srcSet={srcSet} loading={loading} />
+      {children}
+    </ChakraAvatar.Root>
+  )
+})
+
+const AvatarFallback = React.forwardRef(function AvatarFallback(props, ref) {
+  const { name, icon, children, ...rest } = props
+  return (
+    <ChakraAvatar.Fallback ref={ref} {...rest}>
+      {children}
+      {name != null && children == null && <>{getInitials(name)}</>}
+      {name == null && children == null && (
+        <ChakraAvatar.Icon asChild={!!icon}>{icon}</ChakraAvatar.Icon>
+      )}
+    </ChakraAvatar.Fallback>
+  )
+})
+
+function getInitials(name) {
+  const names = name.trim().split(' ')
+  const firstName = names[0] != null ? names[0] : ''
+  const lastName = names.length > 1 ? names[names.length - 1] : ''
+  return firstName && lastName
+    ? `${firstName.charAt(0)}${lastName.charAt(0)}`
+    : firstName.charAt(0)
+}
+
+export const AvatarGroup = React.forwardRef(function AvatarGroup(props, ref) {
+  const { size, variant, borderless, ...rest } = props
+  return (
+    <ChakraAvatar.PropsProvider value={{ size, variant, borderless }}>
+      <Group gap='0' spaceX='-3' ref={ref} {...rest} />
+    </ChakraAvatar.PropsProvider>
+  )
+})

package/waollama/components/ui/checkbox.jsx

@@ -0,0 +1,17 @@
+import { Checkbox as ChakraCheckbox } from '@chakra-ui/react'
+import * as React from 'react'
+
+export const Checkbox = React.forwardRef(function Checkbox(props, ref) {
+  const { icon, children, inputProps, rootRef, ...rest } = props
+  return (
+    <ChakraCheckbox.Root ref={rootRef} {...rest}>
+      <ChakraCheckbox.HiddenInput ref={ref} {...inputProps} />
+      <ChakraCheckbox.Control>
+        {icon || <ChakraCheckbox.Indicator />}
+      </ChakraCheckbox.Control>
+      {children != null && (
+        <ChakraCheckbox.Label>{children}</ChakraCheckbox.Label>
+      )}
+    </ChakraCheckbox.Root>
+  )
+})

package/waollama/components/ui/close-button.jsx

@@ -0,0 +1,20 @@
+function _nullishCoalesce(lhs, rhsFn) {
+  if (lhs != null) {
+    return lhs
+  } else {
+    return rhsFn()
+  }
+}
+import { IconButton as ChakraIconButton } from '@chakra-ui/react'
+import * as React from 'react'
+import { LuX } from 'react-icons/lu'
+
+export const CloseButton = React.forwardRef(function CloseButton(props, ref) {
+  return (
+    <ChakraIconButton variant='ghost' aria-label='Close' ref={ref} {...props}>
+      {_nullishCoalesce(props.children, () => (
+        <LuX />
+      ))}
+    </ChakraIconButton>
+  )
+})

package/waollama/components/ui/color-mode.jsx

@@ -0,0 +1,61 @@
+'use client'
+
+import { ClientOnly, IconButton, Skeleton } from '@chakra-ui/react'
+import { ThemeProvider, useTheme } from 'next-themes'
+
+import * as React from 'react'
+import { LuMoon, LuSun } from 'react-icons/lu'
+
+export function ColorModeProvider(props) {
+  return (
+    <ThemeProvider attribute='class' disableTransitionOnChange {...props} />
+  )
+}
+
+export function useColorMode() {
+  const { resolvedTheme, setTheme } = useTheme()
+  const toggleColorMode = () => {
+    setTheme(resolvedTheme === 'light' ? 'dark' : 'light')
+  }
+  return {
+    colorMode: resolvedTheme,
+    setColorMode: setTheme,
+    toggleColorMode,
+  }
+}
+
+export function useColorModeValue(light, dark) {
+  const { colorMode } = useColorMode()
+  return colorMode === 'dark' ? dark : light
+}
+
+export function ColorModeIcon() {
+  const { colorMode } = useColorMode()
+  return colorMode === 'dark' ? <LuMoon /> : <LuSun />
+}
+
+export const ColorModeButton = React.forwardRef(
+  function ColorModeButton(props, ref) {
+    const { toggleColorMode } = useColorMode()
+    return (
+      <ClientOnly fallback={<Skeleton boxSize='8' />}>
+        <IconButton
+          onClick={toggleColorMode}
+          variant='ghost'
+          aria-label='Toggle color mode'
+          size='sm'
+          ref={ref}
+          {...props}
+          css={{
+            _icon: {
+              width: '5',
+              height: '5',
+            },
+          }}
+        >
+          <ColorModeIcon />
+        </IconButton>
+      </ClientOnly>
+    )
+  },
+)