anymous 1.1.6 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "anymous",
-  "version": "1.1.6",
+  "version": "1.2.0",
   "description": "AI-powered reverse engineering platform",
   "type": "module",
   "license": "MIT",

package/src/cli/cmd/run/splash.ts

@@ -171,7 +171,7 @@ function draw(
   }
 }
 
-const VERSION = "1.1.6"
+const VERSION = "1.2.0"
 
 function build(input: SplashWriterInput, kind: "entry" | "exit", ctx: ScrollbackRenderContext): ScrollbackSnapshot {
   const width = Math.max(1, ctx.width)

package/src/cli/ui.ts

@@ -54,7 +54,7 @@ export function logo(pad?: string) {
       result.push(row)
       result.push(EOL)
     }
-    result.push("AI-Powered Reverse Engineering & Pentest Platform v1.1.6")
+    result.push("AI-Powered Reverse Engineering & Pentest Platform v1.2.0")
     return result.join("")
   }
 
@@ -103,7 +103,7 @@ export function logo(pad?: string) {
     result.push(EOL)
   })
   result.push(Style.TEXT_NORMAL, "─".repeat(45), EOL)
-  result.push(Style.TEXT_INFO, "▸", Style.TEXT_NORMAL, " AI-Powered Reverse Engineering & Pentest Platform  ", Style.TEXT_DIM, "v1.1.6", EOL)
+  result.push(Style.TEXT_INFO, "▸", Style.TEXT_NORMAL, " AI-Powered Reverse Engineering & Pentest Platform  ", Style.TEXT_DIM, "v1.2.0", EOL)
   result.push(Style.TEXT_NORMAL, "─".repeat(45))
   return result.join("").trimEnd()
 }

package/src/memory/memory.ts

@@ -0,0 +1,108 @@
+import { LayerNode } from "@anymous-ai/core/effect/layer-node"
+import { Effect, Layer, Context, Schema, ParseResult } from "effect"
+import { FSUtil } from "@anymous-ai/core/fs-util"
+import { Global } from "@anymous-ai/core/global"
+import path from "path"
+
+const MemoryEntry = Schema.Struct({
+  key: Schema.String,
+  value: Schema.String,
+  timestamp: Schema.Number,
+  sessionID: Schema.optional(Schema.String),
+})
+
+const MemoryStore = Schema.Struct({
+  version: Schema.Literal(1),
+  memories: Schema.Array(MemoryEntry),
+})
+
+interface MemoryEntryType extends Schema.Schema.Type<typeof MemoryEntry> {}
+interface MemoryStoreType extends Schema.Schema.Type<typeof MemoryStore> {}
+
+export interface Interface {
+  readonly read: (key: string) => Effect.Effect<MemoryEntryType | undefined>
+  readonly write: (key: string, value: string, sessionID?: string) => Effect.Effect<void>
+  readonly list: () => Effect.Effect<MemoryEntryType[]>
+  readonly delete: (key: string) => Effect.Effect<boolean>
+  readonly allText: () => Effect.Effect<string | undefined>
+}
+
+export class Service extends Context.Service<Service, Interface>()("@anymous/Memory") {}
+
+const memoryFilePath = (global: { config: string }) => path.join(global.config, "memory.json")
+
+const loadStore = (fs: FSUtil.Interface, filePath: string) =>
+  Effect.gen(function* () {
+    const exists = yield* fs.exists(filePath)
+    if (!exists) {
+      return { version: 1, memories: [] } as MemoryStoreType
+    }
+    const raw = yield* fs.readFileString(filePath)
+    const parsed = JSON.parse(raw) as unknown
+    const decoded = yield* Schema.decodeUnknown(MemoryStore)(parsed).pipe(
+      Effect.catchAll(() => Effect.succeed({ version: 1, memories: [] } as MemoryStoreType)),
+    )
+    return decoded
+  })
+
+const saveStore = (fs: FSUtil.Interface, filePath: string, store: MemoryStoreType) =>
+  Effect.gen(function* () {
+    yield* fs.writeFileString(filePath, JSON.stringify(store, null, 2))
+  })
+
+const layer = Layer.effect(
+  Service,
+  Effect.gen(function* () {
+    const fs = yield* FSUtil.Service
+    const global = yield* Global.Service
+    const filePath = memoryFilePath(global)
+
+    const read: Interface["read"] = Effect.fn("Memory.read")(function* (key: string) {
+      const store = yield* loadStore(fs, filePath)
+      return store.memories.find((m) => m.key === key)
+    })
+
+    const write: Interface["write"] = Effect.fn("Memory.write")(function* (key: string, value: string, sessionID?: string) {
+      const store = yield* loadStore(fs, filePath)
+      const existing = store.memories.findIndex((m) => m.key === key)
+      const entry: MemoryEntryType = { key, value, timestamp: Date.now(), ...(sessionID ? { sessionID } : {}) }
+      if (existing >= 0) {
+        store.memories[existing] = entry
+      } else {
+        store.memories.push(entry)
+      }
+      yield* saveStore(fs, filePath, store)
+    })
+
+    const list: Interface["list"] = Effect.fn("Memory.list")(function* () {
+      const store = yield* loadStore(fs, filePath)
+      return store.memories
+    })
+
+    const remove: Interface["delete"] = Effect.fn("Memory.delete")(function* (key: string) {
+      const store = yield* loadStore(fs, filePath)
+      const idx = store.memories.findIndex((m) => m.key === key)
+      if (idx < 0) return false
+      store.memories.splice(idx, 1)
+      yield* saveStore(fs, filePath, store)
+      return true
+    })
+
+    const allText: Interface["allText"] = Effect.fn("Memory.allText")(function* () {
+      const store = yield* loadStore(fs, filePath)
+      if (store.memories.length === 0) return undefined
+      const lines = store.memories.map((m) => `- ${m.key}: ${m.value}`)
+      return `## Shared Context / Memory\n\n${lines.join("\n")}`
+    })
+
+    return Service.of({ read, write, list, delete: remove, allText })
+  }),
+)
+
+export const node = LayerNode.make({
+  service: Service,
+  layer: layer.pipe(Layer.orDie),
+  deps: [FSUtil.node, Global.node],
+})
+
+export * as Memory from "./memory"

package/src/session/prompt.ts

@@ -47,6 +47,7 @@ import { InstanceState } from "@/effect/instance-state"
 import { TaskTool, type TaskPromptOps } from "@/tool/task"
 import { SessionRunState } from "./run-state"
 import { RuntimeFlags } from "@/effect/runtime-flags"
+import { Memory } from "@/memory/memory"
 import { EventV2Bridge } from "@/event-v2-bridge"
 import { Database } from "@anymous-ai/core/database/database"
 import { ModelV2 } from "@anymous-ai/core/model"
@@ -139,6 +140,7 @@ const layer = Layer.effect(
     const llm = yield* LLM.Service
     const events = yield* EventV2Bridge.Service
     const flags = yield* RuntimeFlags.Service
+    const memory = yield* Memory.Service
     const database = yield* Database.Service
     const { db } = database
     const ops = Effect.fn("SessionPrompt.ops")(function* () {
@@ -1254,16 +1256,18 @@ const layer = Layer.effect(
 
             yield* plugin.trigger("experimental.chat.messages.transform", {}, { messages: msgs })
 
-            const [skills, env, instructions, mcpInstructions, modelMsgs] = yield* Effect.all([
+            const [skills, env, instructions, mcpInstructions, modelMsgs, sharedMemory] = yield* Effect.all([
               sys.skills(agent),
               sys.environment(model),
               instruction.system().pipe(Effect.orDie),
               sys.mcp(agent, session.permission),
               MessageV2.toModelMessagesEffect(msgs, model),
+              memory.allText(),
             ])
             const system = [
               ...env,
               ...instructions,
+              ...(sharedMemory ? [sharedMemory] : []),
               ...(mcpInstructions ? [mcpInstructions] : []),
               ...(skills ? [skills] : []),
             ]
@@ -1624,6 +1628,7 @@ export const node = LayerNode.make({
     LLM.node,
     EventV2Bridge.node,
     RuntimeFlags.node,
+    Memory.node,
     Database.node,
   ],
 })

package/src/tool/computer.ts

@@ -0,0 +1,417 @@
+import { Effect, Schema, pipe } from "effect"
+import * as Tool from "./tool"
+import { spawn } from "child_process"
+import DESCRIPTION from "./computer.txt"
+
+const platform = process.platform
+
+const poweshellScript = (script: string) =>
+  Effect.promise<string>(
+    () =>
+      new Promise((resolve, reject) => {
+        const proc = spawn("powershell", [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          script,
+        ])
+        let stdout = ""
+        let stderr = ""
+        proc.stdout.on("data", (d: Buffer) => (stdout += d.toString()))
+        proc.stderr.on("data", (d: Buffer) => (stderr += d.toString()))
+        proc.on("close", (code) => {
+          if (code === 0) resolve(stdout.trim())
+          else reject(new Error(stderr.trim() || `exit code ${code}`))
+        })
+        proc.on("error", reject)
+      }),
+  )
+
+const captureScreenshot = Effect.fn("Computer.screenshot")(function* () {
+  if (platform === "win32") {
+    const base64 = yield* poweshellScript(`
+Add-Type -AssemblyName System.Drawing
+Add-Type -AssemblyName System.Windows.Forms
+$bounds = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+$bmp = New-Object System.Drawing.Bitmap $bounds.Width, $bounds.Height
+$gfx = [System.Drawing.Graphics]::FromImage($bmp)
+$gfx.CopyFromScreen($bounds.X, $bounds.Y, 0, 0, $bounds.Size)
+$ms = New-Object System.IO.MemoryStream
+$bmp.Save($ms, [System.Drawing.Imaging.ImageFormat]::Png)
+$bytes = $ms.ToArray()
+[Convert]::ToBase64String($bytes)
+$gfx.Dispose()
+$bmp.Dispose()
+$ms.Dispose()
+`)
+    return `data:image/png;base64,${base64}`
+  }
+  if (platform === "darwin") {
+    const base64 = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("screencapture", ["-x", "-t", "png", "-"])
+          const chunks: Buffer[] = []
+          proc.stdout.on("data", (d: Buffer) => chunks.push(d))
+          proc.on("close", (code) => {
+            if (code === 0) resolve(Buffer.concat(chunks).toString("base64"))
+            else reject(new Error(`screencapture exit code ${code}`))
+          })
+          proc.on("error", reject)
+        }),
+    )
+    return `data:image/png;base64,${base64}`
+  }
+  if (platform === "linux") {
+    const base64 = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("import", ["-window", "root", "png:-"])
+          const chunks: Buffer[] = []
+          proc.stdout.on("data", (d: Buffer) => chunks.push(d))
+          proc.on("close", (code) => {
+            if (code === 0) resolve(Buffer.concat(chunks).toString("base64"))
+            else reject(new Error(`import exit code ${code}`))
+          })
+          proc.on("error", reject)
+        }),
+    )
+    return `data:image/png;base64,${base64}`
+  }
+  return yield* Effect.fail(new Error(`Unsupported platform: ${platform}`))
+})
+
+const moveMouse = Effect.fn("Computer.moveMouse")(function* (x: number, y: number) {
+  if (platform === "win32") {
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Position = New-Object System.Drawing.Point(${Math.round(x)}, ${Math.round(y)})
+`)
+  } else if (platform === "darwin") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to set position of mouse to {${Math.round(x)}, ${Math.round(y)}}`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["mousemove", String(Math.round(x)), String(Math.round(y))])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const clickMouse = Effect.fn("Computer.clickMouse")(function* (button: "left" | "right" | "middle") {
+  if (platform === "win32") {
+    const btn = button === "left" ? "[MouseButtons]::Left" : button === "right" ? "[MouseButtons]::Right" : "[MouseButtons]::Middle"
+    const down = button === "left" ? "0x2" : button === "right" ? "0x8" : "0x20"
+    const up = button === "left" ? "0x4" : button === "right" ? "0x10" : "0x40"
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.Cursor]::Click()
+`)
+  } else if (platform === "darwin") {
+    const btn = button === "left" ? "click" : button === "right" ? "click at (get position of mouse) using {button 2}" : "click at (get position of mouse) using {button 3}"
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to ${btn}`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    const btn = button === "left" ? "1" : button === "right" ? "3" : "2"
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["click", btn])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const typeText = Effect.fn("Computer.typeText")(function* (text: string) {
+  if (platform === "win32") {
+    const escaped = text.replace(/"/g, '`"').replace(/\$/g, "`$").replace(/\n/g, "`n").replace(/\r/g, "`r").replace(/\t/g, "`t")
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${escaped}")
+`)
+  } else if (platform === "darwin") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to keystroke "${text.replace(/"/g, '\\"')}"`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["type", text])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const keyPress = Effect.fn("Computer.keyPress")(function* (keys: string[]) {
+  const combo = keys.join("+")
+  if (platform === "win32") {
+    const mapping: Record<string, string> = {
+      ctrl: "^", alt: "%", shift: "+", enter: "{ENTER}", tab: "{TAB}",
+      escape: "{ESC}", backspace: "{BACKSPACE}", delete: "{DELETE}",
+      up: "{UP}", down: "{DOWN}", left: "{LEFT}", right: "{RIGHT}",
+      home: "{HOME}", end: "{END}", pageup: "{PGUP}", pagedown: "{PGDN}",
+    }
+    const translated = keys.map((k) => mapping[k.toLowerCase()] ?? k.toUpperCase())
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("${translated.join("")}")
+`)
+  } else if (platform === "darwin") {
+    const mapping: Record<string, string> = {
+      ctrl: "command down", alt: "option down", shift: "shift down",
+      enter: "return", escape: "escape", tab: "tab",
+      backspace: "delete", delete: "forward delete",
+      up: "up", down: "down", left: "left", right: "right",
+    }
+    const parts = keys.map((k) => mapping[k.toLowerCase()] ?? `"${k}"`)
+    const cmd = `tell application "System Events" to key code ${keys.length > 0 ? `using {${parts.join(", ")}}` : ""}`
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", ["-e", cmd])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["key", combo])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const scrollMouse = Effect.fn("Computer.scrollMouse")(function* (clicks: number) {
+  if (platform === "win32") {
+    yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+[System.Windows.Forms.SendKeys]::SendWait("{${clicks > 0 ? "UP" : "DOWN"} ${Math.abs(clicks)}}")
+`)
+  } else if (platform === "darwin") {
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("osascript", [
+          "-e",
+          `tell application "System Events" to scroll wheel ${clicks} lines`,
+        ])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  } else if (platform === "linux") {
+    const btn = clicks > 0 ? "4" : "5"
+    const count = Math.abs(clicks)
+    yield* Effect.promise(() =>
+      new Promise<void>((resolve, reject) => {
+        const proc = spawn("xdotool", ["click", `--repeat`, String(count), btn])
+        proc.on("close", (code) => (code === 0 ? resolve() : reject(new Error(`exit ${code}`))))
+        proc.on("error", reject)
+      }),
+    )
+  }
+})
+
+const getScreenSize = Effect.fn("Computer.screenSize")(function* () {
+  if (platform === "win32") {
+    const raw = yield* poweshellScript(`
+Add-Type -AssemblyName System.Windows.Forms
+$s = [System.Windows.Forms.Screen]::PrimaryScreen.Bounds
+Write-Output "$($s.Width) $($s.Height)"
+`)
+    const [w, h] = raw.split(" ").map(Number)
+    return { width: w, height: h }
+  }
+  if (platform === "darwin") {
+    const raw = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("osascript", [
+            "-e",
+            `tell application "Finder" to get bounds of window of desktop`,
+          ])
+          let d = ""
+          proc.stdout.on("data", (b: Buffer) => (d += b.toString()))
+          proc.on("close", (code) => (code === 0 ? resolve(d.trim()) : reject(new Error(`exit ${code}`))))
+          proc.on("error", reject)
+        }),
+    )
+    const [_, __, w, h] = d.split(", ").map(Number)
+    return { width: w, height: h }
+  }
+  if (platform === "linux") {
+    const raw = yield* Effect.promise<string>(
+      () =>
+        new Promise((resolve, reject) => {
+          const proc = spawn("xdotool", ["getdisplaygeometry"])
+          let d = ""
+          proc.stdout.on("data", (b: Buffer) => (d += b.toString()))
+          proc.on("close", (code) => (code === 0 ? resolve(d.trim()) : reject(new Error(`exit ${code}`))))
+          proc.on("error", reject)
+        }),
+    )
+    const [w, h] = raw.split(/\s+/).map(Number)
+    return { width: w, height: h }
+  }
+  return yield* Effect.fail(new Error(`Unsupported platform: ${platform}`))
+})
+
+export const Action = Schema.Struct({
+  action: Schema.Literal("screenshot", "click", "doubleclick", "rightclick", "move", "type", "keypress", "scroll", "screensize"),
+  x: Schema.optional(Schema.Number).annotate({ description: "X coordinate for click/move actions" }),
+  y: Schema.optional(Schema.Number).annotate({ description: "Y coordinate for click/move actions" }),
+  text: Schema.optional(Schema.String).annotate({ description: "Text to type (for type action)" }),
+  keys: Schema.optional(Schema.Array(Schema.String)).annotate({ description: "Keys to press (for keypress action), e.g. ['ctrl', 'c']" }),
+  button: Schema.optional(Schema.Literal("left", "right", "middle")).annotate({ description: "Mouse button (default: left)" }),
+  clicks: Schema.optional(Schema.Number).annotate({ description: "Scroll clicks (positive=up, negative=down)" }),
+})
+
+export const ComputerTool = Tool.define<typeof Action, {}, Question.Service>(
+  "computer",
+  Effect.gen(function* () {
+    return {
+      description: DESCRIPTION,
+      parameters: Action,
+      execute: (params: Schema.Schema.Type<typeof Action>) =>
+        Effect.gen(function* () {
+          const { action } = params
+
+          if (action === "screenshot") {
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: "Captured screenshot",
+              output: "Screenshot captured. Use the image to decide the next action.",
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "move") {
+            yield* moveMouse(params.x!, params.y!)
+            return { title: "Mouse moved", output: `Mouse moved to (${params.x}, ${params.y})`, metadata: {} }
+          }
+
+          if (action === "click" || action === "doubleclick" || action === "rightclick") {
+            if (params.x != null && params.y != null) {
+              yield* moveMouse(params.x, params.y)
+            }
+            const btn = action === "rightclick" ? "right" : (params.button ?? "left")
+            yield* clickMouse(btn as "left" | "right" | "middle")
+            if (action === "doubleclick") {
+              yield* clickMouse(btn as "left" | "right" | "middle")
+            }
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `${action} at (${params.x ?? "current"}, ${params.y ?? "current"})`,
+              output: `Performed ${action}. Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "type") {
+            yield* typeText(params.text!)
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `Typed text`,
+              output: `Typed "${params.text!.length > 50 ? params.text!.slice(0, 50) + "..." : params.text!}". Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "keypress") {
+            yield* keyPress(params.keys!)
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `Key press: ${params.keys!.join("+")}`,
+              output: `Pressed ${params.keys!.join("+")}. Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "scroll") {
+            yield* scrollMouse(params.clicks ?? 3)
+            const dataUrl = yield* captureScreenshot
+            return {
+              title: `Scrolled ${params.clicks ?? 3} clicks`,
+              output: `Scrolled. Screenshot shows the result.`,
+              attachments: [{
+                type: "file",
+                mime: "image/png",
+                filename: "screenshot.png",
+                url: dataUrl,
+              }],
+              metadata: {},
+            }
+          }
+
+          if (action === "screensize") {
+            const size = yield* getScreenSize
+            return {
+              title: "Screen size",
+              output: `Screen resolution: ${size.width}x${size.height}`,
+              metadata: {},
+            }
+          }
+
+          return {
+            title: "Unknown action",
+            output: `Unknown action: ${action}`,
+            metadata: {},
+          }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/computer.txt

@@ -0,0 +1,16 @@
+Control the computer screen — capture screenshots, move mouse, click, type text, press keys, and scroll. Returns a screenshot after most actions so you can see the result. Use this to navigate applications, interact with UIs, fill forms, click buttons, and control the desktop.
+
+Available actions:
+- screenshot: Capture current screen (returns image, no side effects)
+- move (x, y): Move mouse to coordinates
+- click (x?, y?, button?): Click at position (default: left button)
+- doubleclick (x?, y?): Double-click at position
+- rightclick (x?, y?): Right-click at position
+- type (text): Type text at current cursor position
+- keypress (keys): Press key combination (e.g. ["ctrl", "c"], ["alt", "tab"], ["enter"])
+- scroll (clicks): Scroll up (positive) or down (negative)
+- screensize: Get screen dimensions
+
+Coordinate system: (0,0) is top-left corner of primary screen. Get screen dimensions via screensize action.
+
+Platform support: Windows (native), macOS (via screencapture + osascript), Linux (via ImageMagick + xdotool).

package/src/tool/memory.ts

@@ -0,0 +1,59 @@
+import { Effect, Schema } from "effect"
+import * as Tool from "./tool"
+import { Memory } from "@/memory/memory"
+import DESCRIPTION from "./memory.txt"
+
+export const Parameters = Schema.Struct({
+  action: Schema.Literal("read", "write", "delete", "list").annotate({ description: "Action to perform" }),
+  key: Schema.optional(Schema.String).annotate({ description: "Memory key (required for read/write/delete)" }),
+  value: Schema.optional(Schema.String).annotate({ description: "Memory value (required for write)" }),
+})
+
+export const MemoryTool = Tool.define<typeof Parameters, {}, Memory.Service>(
+  "memory",
+  Effect.gen(function* () {
+    const memory = yield* Memory.Service
+
+    return {
+      description: DESCRIPTION,
+      parameters: Parameters,
+      execute: (params: Schema.Schema.Type<typeof Parameters>) =>
+        Effect.gen(function* () {
+          const { action, key, value } = params
+
+          if (action === "list") {
+            const entries = yield* memory.list()
+            if (entries.length === 0) {
+              return { title: "No memories", output: "No memories stored.", metadata: {} }
+            }
+            const formatted = entries.map((e) => `- ${e.key}: ${e.value}`).join("\n")
+            return { title: `Listed ${entries.length} memories`, output: formatted, metadata: {} }
+          }
+
+          if (action === "read") {
+            if (!key) return { title: "Error", output: "Key is required for read action.", metadata: {} }
+            const entry = yield* memory.read(key)
+            if (!entry) return { title: "Not found", output: `No memory found for key "${key}".`, metadata: {} }
+            return { title: `Read memory: ${key}`, output: entry.value, metadata: {} }
+          }
+
+          if (action === "write") {
+            if (!key || !value) {
+              return { title: "Error", output: "Both key and value are required for write action.", metadata: {} }
+            }
+            yield* memory.write(key, value)
+            return { title: `Memory saved: ${key}`, output: `Saved memory "${key}".`, metadata: {} }
+          }
+
+          if (action === "delete") {
+            if (!key) return { title: "Error", output: "Key is required for delete action.", metadata: {} }
+            const deleted = yield* memory.delete(key)
+            if (!deleted) return { title: "Not found", output: `No memory found for key "${key}".`, metadata: {} }
+            return { title: `Memory deleted: ${key}`, output: `Deleted memory "${key}".`, metadata: {} }
+          }
+
+          return { title: "Unknown action", output: `Unknown action: ${action}`, metadata: {} }
+        }).pipe(Effect.orDie),
+    }
+  }),
+)

package/src/tool/memory.txt

@@ -0,0 +1,14 @@
+Persistent shared context memory that persists across sessions. Use this to remember important information about the project, user preferences, architecture decisions, credentials, or any context you want to carry between sessions.
+
+Actions:
+- read (key): Read a specific memory
+- write (key, value): Save or update a memory
+- delete (key): Remove a memory
+- list: List all memories
+
+Memories are automatically injected into the system prompt at the start of every session as shared context. Use this for:
+- Project architecture decisions
+- Coding conventions and preferences
+- Authentication tokens or API keys
+- Important findings or TODOs
+- User preferences for how you should behave

package/src/tool/registry.ts

@@ -2,6 +2,8 @@ import { LayerNode } from "@anymous-ai/core/effect/layer-node"
 import { httpClient } from "@anymous-ai/core/effect/app-node-platform"
 import { Ripgrep } from "@anymous-ai/core/ripgrep"
 import { PlanExitTool } from "./plan"
+import { ComputerTool } from "./computer"
+import { MemoryTool } from "./memory"
 import { Session } from "@/session/session"
 import { QuestionTool } from "./question"
 import { ShellTool } from "./shell"
@@ -100,6 +102,8 @@ const layer = Layer.effect(
     const todo = yield* TodoWriteTool
     const lsptool = yield* LspTool
     const plan = yield* PlanExitTool
+    const computer = yield* ComputerTool
+    const memorytool = yield* MemoryTool
     const webfetch = yield* WebFetchTool
     const websearch = yield* WebSearchTool
     const shell = yield* ShellTool
@@ -218,6 +222,8 @@ const layer = Layer.effect(
           question: Tool.init(question),
           lsp: Tool.init(lsptool),
           plan: Tool.init(plan),
+          computer: Tool.init(computer),
+          memory: Tool.init(memorytool),
           ...(codeModeTool ? { execute: Tool.init(codeModeTool) } : {}),
         })
 
@@ -240,6 +246,8 @@ const layer = Layer.effect(
             tool.patch,
             ...(tool.execute ? [tool.execute] : []),
             ...(flags.experimentalLspTool ? [tool.lsp] : []),
+            tool.computer,
+            tool.memory,
             ...(flags.experimentalPlanMode && flags.client === "cli" ? [tool.plan] : []),
           ],
           task: tool.task,