experimental-agent 0.0.2 → 0.0.4

package/dist/agent-workflow.mjs

@@ -1,9 +1,13 @@
 import {
   agentMessageHook,
-  agentWorkflow
-} from "./chunk-PGYYQ3WZ.mjs";
+  agentWorkflow,
+  approvalHook
+} from "./chunk-JCPQQWIK.mjs";
+import "./chunk-64THY7Y7.mjs";
+import "./chunk-3ODWQVIA.mjs";
 export {
   agentMessageHook,
-  agentWorkflow
+  agentWorkflow,
+  approvalHook
 };
 //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/chunk-3ODWQVIA.mjs

@@ -0,0 +1,12 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined")
+    return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+export {
+  __require
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFtdLAogICJtYXBwaW5ncyI6ICIiLAogICJuYW1lcyI6IFtdCn0K

package/dist/chunk-64THY7Y7.mjs

@@ -0,0 +1,155 @@
+// src/sandbox/process-manager.ts
+var DEFAULT_WAIT_UNTIL = 2e3;
+var RUN_SCRIPT = `#!/bin/sh
+# Process runner for Agent SDK
+# All parameters passed via environment variables to avoid escaping issues
+# Output is base64 encoded to avoid JSON escaping issues
+
+AGENT_DIR="$HOME/.agent"
+CWD_FILE="$AGENT_DIR/cwd/$SESSION_ID"
+
+# Get current working directory (per-session)
+if [ -f "$CWD_FILE" ]; then
+  CWD=$(cat "$CWD_FILE")
+else
+  CWD="$HOME"
+fi
+
+# Decode command
+CMD=$(echo "$CMD_BASE64" | base64 -d)
+
+# Background mode (waitUntil = 0)
+if [ "$WAIT_UNTIL" = "0" ]; then
+  cd "$CWD" || cd "$HOME"
+
+  # Generate a simple numeric ID for output file
+  OUTPUT_ID="$(date +%s)$$"
+  OUTPUT_FILE="$AGENT_DIR/outputs/$OUTPUT_ID.log"
+
+  # Double-fork to fully detach the process
+  (
+    (
+      eval "$CMD"
+      pwd > "$CWD_FILE" 2>/dev/null
+    ) > "$OUTPUT_FILE" 2>&1 < /dev/null &
+    echo $! > "$AGENT_DIR/pids/$OUTPUT_ID.pid"
+  )
+
+  # Small delay to ensure PID file is written
+  sleep 0.05
+
+  # Read PID
+  if [ -f "$AGENT_DIR/pids/$OUTPUT_ID.pid" ]; then
+    PID=$(cat "$AGENT_DIR/pids/$OUTPUT_ID.pid")
+  else
+    PID=0
+  fi
+
+  # Output JSON result (no output for background, so no encoding needed)
+  printf '{"pid":%d,"outputBase64":"","exitCode":-1,"status":"running","outputFile":"%s","cwd":"%s"}\\n' \\
+    "$PID" "$OUTPUT_FILE" "$CWD"
+  exit 0
+fi
+
+# Foreground mode (waitUntil > 0) - run directly and capture output
+cd "$CWD" || cd "$HOME"
+
+# Run command, capture output and exit code
+OUTPUT=$(eval "$CMD" 2>&1)
+EXIT_CODE=$?
+
+# Update CWD after command
+NEW_CWD=$(pwd)
+echo "$NEW_CWD" > "$CWD_FILE"
+
+# Determine status
+if [ $EXIT_CODE -eq 0 ]; then
+  STATUS="completed"
+else
+  STATUS="failed"
+fi
+
+# Base64 encode output to avoid ALL escaping issues
+OUTPUT_BASE64=$(printf '%s' "$OUTPUT" | base64 | tr -d '\\n')
+
+# Output JSON result with base64-encoded output
+printf '{"pid":0,"outputBase64":"%s","exitCode":%d,"status":"%s","outputFile":"","cwd":"%s"}\\n' \\
+  "$OUTPUT_BASE64" "$EXIT_CODE" "$STATUS" "$NEW_CWD"
+`;
+var createProcessManager = (opts) => {
+  const { sandbox, sessionId } = opts;
+  let initialized = false;
+  const init = async () => {
+    if (initialized) {
+      return;
+    }
+    const result = await sandbox.exec({
+      command: "sh",
+      args: [
+        "-c",
+        `mkdir -p $HOME/.agent/bin $HOME/.agent/pids $HOME/.agent/outputs $HOME/.agent/cwd
+cat > $HOME/.agent/bin/run.sh << 'SCRIPT_EOF'
+${RUN_SCRIPT}
+SCRIPT_EOF
+chmod +x $HOME/.agent/bin/run.sh`
+      ]
+    });
+    if (result instanceof Error) {
+      throw result;
+    }
+    await result.result;
+    initialized = true;
+  };
+  const run = async (opts2) => {
+    await init();
+    const { command, waitUntil = DEFAULT_WAIT_UNTIL } = opts2;
+    const cmdBase64 = Buffer.from(command, "utf-8").toString("base64");
+    const result = await sandbox.exec({
+      command: "sh",
+      args: [
+        "-c",
+        `CMD_BASE64="${cmdBase64}" WAIT_UNTIL="${waitUntil}" SESSION_ID="${sessionId}" $HOME/.agent/bin/run.sh`
+      ]
+    });
+    if (result instanceof Error) {
+      throw result;
+    }
+    const { stdout } = await result.result;
+    const parsed = JSON.parse(stdout.trim());
+    const output = parsed.outputBase64 ? Buffer.from(parsed.outputBase64, "base64").toString("utf-8") : "";
+    return {
+      pid: parsed.pid,
+      output,
+      exitCode: parsed.exitCode,
+      status: parsed.status,
+      cwd: parsed.cwd,
+      outputFile: parsed.outputFile
+    };
+  };
+  const getCwd = async () => {
+    await init();
+    const result = await sandbox.exec({
+      command: "sh",
+      args: [
+        "-c",
+        `cat $HOME/.agent/cwd/${sessionId} 2>/dev/null || echo "$HOME"`
+      ]
+    });
+    if (result instanceof Error) {
+      return process.cwd();
+    }
+    const { stdout } = await result.result;
+    return stdout.trim() || process.cwd();
+  };
+  return {
+    init,
+    run,
+    getCwd
+  };
+};
+
+export {
+  DEFAULT_WAIT_UNTIL,
+  createProcessManager
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/sandbox/process-manager.ts"],
  "sourcesContent": ["import type { BashResult, Sandbox } from \"./types\";\n\nexport const DEFAULT_WAIT_UNTIL = 2000;\n\n/**\n * Shell script that handles all process execution logic.\n * Installed to ~/.agent/bin/run.sh during init().\n */\nconst RUN_SCRIPT = `#!/bin/sh\n# Process runner for Agent SDK\n# All parameters passed via environment variables to avoid escaping issues\n# Output is base64 encoded to avoid JSON escaping issues\n\nAGENT_DIR=\"$HOME/.agent\"\nCWD_FILE=\"$AGENT_DIR/cwd/$SESSION_ID\"\n\n# Get current working directory (per-session)\nif [ -f \"$CWD_FILE\" ]; then\n  CWD=$(cat \"$CWD_FILE\")\nelse\n  CWD=\"$HOME\"\nfi\n\n# Decode command\nCMD=$(echo \"$CMD_BASE64\" | base64 -d)\n\n# Background mode (waitUntil = 0)\nif [ \"$WAIT_UNTIL\" = \"0\" ]; then\n  cd \"$CWD\" || cd \"$HOME\"\n\n  # Generate a simple numeric ID for output file\n  OUTPUT_ID=\"$(date +%s)$$\"\n  OUTPUT_FILE=\"$AGENT_DIR/outputs/$OUTPUT_ID.log\"\n\n  # Double-fork to fully detach the process\n  (\n    (\n      eval \"$CMD\"\n      pwd > \"$CWD_FILE\" 2>/dev/null\n    ) > \"$OUTPUT_FILE\" 2>&1 < /dev/null &\n    echo $! > \"$AGENT_DIR/pids/$OUTPUT_ID.pid\"\n  )\n\n  # Small delay to ensure PID file is written\n  sleep 0.05\n\n  # Read PID\n  if [ -f \"$AGENT_DIR/pids/$OUTPUT_ID.pid\" ]; then\n    PID=$(cat \"$AGENT_DIR/pids/$OUTPUT_ID.pid\")\n  else\n    PID=0\n  fi\n\n  # Output JSON result (no output for background, so no encoding needed)\n  printf '{\"pid\":%d,\"outputBase64\":\"\",\"exitCode\":-1,\"status\":\"running\",\"outputFile\":\"%s\",\"cwd\":\"%s\"}\\\\n' \\\\\n    \"$PID\" \"$OUTPUT_FILE\" \"$CWD\"\n  exit 0\nfi\n\n# Foreground mode (waitUntil > 0) - run directly and capture output\ncd \"$CWD\" || cd \"$HOME\"\n\n# Run command, capture output and exit code\nOUTPUT=$(eval \"$CMD\" 2>&1)\nEXIT_CODE=$?\n\n# Update CWD after command\nNEW_CWD=$(pwd)\necho \"$NEW_CWD\" > \"$CWD_FILE\"\n\n# Determine status\nif [ $EXIT_CODE -eq 0 ]; then\n  STATUS=\"completed\"\nelse\n  STATUS=\"failed\"\nfi\n\n# Base64 encode output to avoid ALL escaping issues\nOUTPUT_BASE64=$(printf '%s' \"$OUTPUT\" | base64 | tr -d '\\\\n')\n\n# Output JSON result with base64-encoded output\nprintf '{\"pid\":0,\"outputBase64\":\"%s\",\"exitCode\":%d,\"status\":\"%s\",\"outputFile\":\"\",\"cwd\":\"%s\"}\\\\n' \\\\\n  \"$OUTPUT_BASE64\" \"$EXIT_CODE\" \"$STATUS\" \"$NEW_CWD\"\n`;\n\ntype RunOptions = {\n  command: string;\n  /**\n   * Max ms to wait for completion.\n   * - 0: Background mode - return immediately with PID\n   * - >0: Foreground mode - wait for completion (default: 30000)\n   */\n  waitUntil?: number;\n};\n\n/**\n * Process manager that uses a single shell script to handle all execution logic.\n * Reduces round-trips to the sandbox by doing everything in one exec call.\n */\nexport const createProcessManager = (opts: {\n  sandbox: Sandbox;\n  sessionId: string;\n}) => {\n  const { sandbox, sessionId } = opts;\n  let initialized = false;\n\n  const init = async (): Promise<void> => {\n    if (initialized) {\n      return;\n    }\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `mkdir -p $HOME/.agent/bin $HOME/.agent/pids $HOME/.agent/outputs $HOME/.agent/cwd\ncat > $HOME/.agent/bin/run.sh << 'SCRIPT_EOF'\n${RUN_SCRIPT}\nSCRIPT_EOF\nchmod +x $HOME/.agent/bin/run.sh`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      throw result;\n    }\n    await result.result;\n    initialized = true;\n  };\n\n  const run = async (opts: RunOptions): Promise<BashResult> => {\n    await init();\n\n    const { command, waitUntil = DEFAULT_WAIT_UNTIL } = opts;\n    const cmdBase64 = Buffer.from(command, \"utf-8\").toString(\"base64\");\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `CMD_BASE64=\"${cmdBase64}\" WAIT_UNTIL=\"${waitUntil}\" SESSION_ID=\"${sessionId}\" $HOME/.agent/bin/run.sh`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      throw result;\n    }\n\n    const { stdout } = await result.result;\n    const parsed = JSON.parse(stdout.trim()) as {\n      pid: number;\n      outputBase64: string;\n      exitCode: number;\n      status: \"running\" | \"completed\" | \"failed\";\n      outputFile: string;\n      cwd: string;\n    };\n\n    // Decode base64 output\n    const output = parsed.outputBase64\n      ? Buffer.from(parsed.outputBase64, \"base64\").toString(\"utf-8\")\n      : \"\";\n\n    return {\n      pid: parsed.pid,\n      output,\n      exitCode: parsed.exitCode,\n      status: parsed.status,\n      cwd: parsed.cwd,\n      outputFile: parsed.outputFile,\n    };\n  };\n\n  const getCwd = async (): Promise<string> => {\n    await init();\n\n    const result = await sandbox.exec({\n      command: \"sh\",\n      args: [\n        \"-c\",\n        `cat $HOME/.agent/cwd/${sessionId} 2>/dev/null || echo \"$HOME\"`,\n      ],\n    });\n\n    if (result instanceof Error) {\n      return process.cwd();\n    }\n\n    const { stdout } = await result.result;\n    return stdout.trim() || process.cwd();\n  };\n\n  return {\n    init,\n    run,\n    getCwd,\n  };\n};\n\nexport type ProcessManager = ReturnType<typeof createProcessManager>;\n"],
  "mappings": ";AAEO,IAAM,qBAAqB;AAMlC,IAAM,aAAa;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA2FZ,IAAM,uBAAuB,CAAC,SAG/B;AACJ,QAAM,EAAE,SAAS,UAAU,IAAI;AAC/B,MAAI,cAAc;AAElB,QAAM,OAAO,YAA2B;AACtC,QAAI,aAAa;AACf;AAAA,IACF;AAEA,UAAM,SAAS,MAAM,QAAQ,KAAK;AAAA,MAChC,SAAS;AAAA,MACT,MAAM;AAAA,QACJ;AAAA,QACA;AAAA;AAAA,EAEN,UAAU;AAAA;AAAA;AAAA,MAGN;AAAA,IACF,CAAC;AAED,QAAI,kBAAkB,OAAO;AAC3B,YAAM;AAAA,IACR;AACA,UAAM,OAAO;AACb,kBAAc;AAAA,EAChB;AAEA,QAAM,MAAM,OAAOA,UAA0C;AAC3D,UAAM,KAAK;AAEX,UAAM,EAAE,SAAS,YAAY,mBAAmB,IAAIA;AACpD,UAAM,YAAY,OAAO,KAAK,SAAS,OAAO,EAAE,SAAS,QAAQ;AAEjE,UAAM,SAAS,MAAM,QAAQ,KAAK;AAAA,MAChC,SAAS;AAAA,MACT,MAAM;AAAA,QACJ;AAAA,QACA,eAAe,SAAS,iBAAiB,SAAS,iBAAiB,SAAS;AAAA,MAC9E;AAAA,IACF,CAAC;AAED,QAAI,kBAAkB,OAAO;AAC3B,YAAM;AAAA,IACR;AAEA,UAAM,EAAE,OAAO,IAAI,MAAM,OAAO;AAChC,UAAM,SAAS,KAAK,MAAM,OAAO,KAAK,CAAC;AAUvC,UAAM,SAAS,OAAO,eAClB,OAAO,KAAK,OAAO,cAAc,QAAQ,EAAE,SAAS,OAAO,IAC3D;AAEJ,WAAO;AAAA,MACL,KAAK,OAAO;AAAA,MACZ;AAAA,MACA,UAAU,OAAO;AAAA,MACjB,QAAQ,OAAO;AAAA,MACf,KAAK,OAAO;AAAA,MACZ,YAAY,OAAO;AAAA,IACrB;AAAA,EACF;AAEA,QAAM,SAAS,YAA6B;AAC1C,UAAM,KAAK;AAEX,UAAM,SAAS,MAAM,QAAQ,KAAK;AAAA,MAChC,SAAS;AAAA,MACT,MAAM;AAAA,QACJ;AAAA,QACA,wBAAwB,SAAS;AAAA,MACnC;AAAA,IACF,CAAC;AAED,QAAI,kBAAkB,OAAO;AAC3B,aAAO,QAAQ,IAAI;AAAA,IACrB;AAEA,UAAM,EAAE,OAAO,IAAI,MAAM,OAAO;AAChC,WAAO,OAAO,KAAK,KAAK,QAAQ,IAAI;AAAA,EACtC;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
  "names": ["opts"]
}


package/dist/chunk-GSRJYPWF.mjs

@@ -0,0 +1,284 @@
+import {
+  MessageNotFoundError,
+  SandboxNotFoundError,
+  SessionNotFoundError,
+  StorageError
+} from "./chunk-HJGPUEFC.mjs";
+
+// src/storage/client.ts
+function getStorageClient(rpcFn, name) {
+  async function rpc(method, params) {
+    const result = await rpcFn({ name, method, params });
+    if ("error" in result) {
+      throw new StorageError({ reason: result.error.message });
+    }
+    return result.result;
+  }
+  return {
+    session: {
+      get: async (id) => {
+        try {
+          const result = await rpc("session.get", { id });
+          if (result === null) {
+            return new SessionNotFoundError({ id });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (session) => {
+        try {
+          return await rpc("session.set", session);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (opts) => {
+        try {
+          return await rpc("session.list", {
+            tags: opts?.tags,
+            order: opts?.order,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      tag: {
+        set: async ({ sessionId, tags }) => {
+          try {
+            return await rpc("session.tag.set", { sessionId, tags });
+          } catch (e) {
+            if (e instanceof StorageError) {
+              return e;
+            }
+            return new StorageError({ reason: String(e), cause: e });
+          }
+        }
+      }
+    },
+    message: {
+      list: async (sessionId, opts) => {
+        try {
+          return await rpc("message.list", {
+            sessionId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      get: async (id) => {
+        try {
+          const result = await rpc("message.get", { id });
+          if (result === null) {
+            return new MessageNotFoundError({ id });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (message) => {
+        try {
+          return await rpc("message.set", message);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    part: {
+      listByMessage: async (messageId, opts) => {
+        try {
+          const result = await rpc("part.listByMessage", {
+            messageId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      listBySession: async (sessionId, opts) => {
+        try {
+          const result = await rpc("part.listBySession", {
+            sessionId,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (part) => {
+        try {
+          return await rpc("part.set", part);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      delete: async (id) => {
+        try {
+          await rpc("part.delete", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    },
+    sandbox: {
+      get: async (key) => {
+        try {
+          const result = await rpc("sandbox.get", { key });
+          if (result === null) {
+            return new SandboxNotFoundError({ id: key });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      getBySession: async (sessionId) => {
+        try {
+          const result = await rpc("sandbox.getBySession", { sessionId });
+          if (result === null) {
+            return new SandboxNotFoundError({ id: sessionId });
+          }
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (record) => {
+        try {
+          await rpc("sandbox.set", record);
+          return record;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (opts) => {
+        try {
+          return await rpc("sandbox.list", {
+            tags: opts?.tags,
+            order: opts?.order,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      tag: {
+        set: async ({ sandboxId, tags }) => {
+          try {
+            return await rpc("sandbox.tag.set", { sandboxId, tags });
+          } catch (e) {
+            if (e instanceof StorageError) {
+              return e;
+            }
+            return new StorageError({ reason: String(e), cause: e });
+          }
+        }
+      }
+    },
+    command: {
+      get: async (id) => {
+        try {
+          return await rpc("command.get", { id });
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      set: async (command) => {
+        try {
+          return await rpc("command.set", command);
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      },
+      list: async (sessionId, opts) => {
+        try {
+          const result = await rpc("command.list", {
+            sessionId,
+            includeFinished: opts?.includeFinished,
+            cursor: opts?.cursor,
+            limit: opts?.limit
+          });
+          return result;
+        } catch (e) {
+          if (e instanceof StorageError) {
+            return e;
+          }
+          return new StorageError({ reason: String(e), cause: e });
+        }
+      }
+    }
+  };
+}
+var DEFAULT_NAMESPACE = "default";
+var LOCAL_STORAGE_VERSION = "v1";
+function getStorage(opts) {
+  const name = opts.config.name ?? DEFAULT_NAMESPACE;
+  return getStorageClient(opts.rpc, name);
+}
+
+export {
+  getStorageClient,
+  DEFAULT_NAMESPACE,
+  LOCAL_STORAGE_VERSION,
+  getStorage
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/storage/client.ts"],
  "sourcesContent": ["import type { z } from \"zod\";\nimport {\n  MessageNotFoundError,\n  SandboxNotFoundError,\n  SessionNotFoundError,\n  StorageError,\n} from \"../errors\";\nimport type { StorageMethods } from \"./rpc\";\nimport type {\n  Command,\n  ListResult,\n  Part,\n  Storage,\n  StorageConfig,\n} from \"./types\";\n\ntype RpcResponse<T> =\n  | { result: T }\n  | { error: { code: string; message: string } };\n\nexport type RpcFn = (params: {\n  name?: string;\n  method: string;\n  params: unknown;\n}) => Promise<RpcResponse<unknown>>;\n\nexport function getStorageClient(rpcFn: RpcFn, name?: string): Storage {\n  async function rpc<M extends keyof StorageMethods>(\n    method: M,\n    params: z.infer<StorageMethods[M][\"params\"]>\n  ): Promise<z.infer<StorageMethods[M][\"result\"]>> {\n    const result = await rpcFn({ name, method, params });\n\n    if (\"error\" in result) {\n      throw new StorageError({ reason: result.error.message });\n    }\n\n    return result.result as z.infer<StorageMethods[M][\"result\"]>;\n  }\n\n  return {\n    session: {\n      get: async (id) => {\n        try {\n          const result = await rpc(\"session.get\", { id });\n          if (result === null) {\n            return new SessionNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (session) => {\n        try {\n          return await rpc(\"session.set\", session);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"session.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sessionId, tags }) => {\n          try {\n            return await rpc(\"session.tag.set\", { sessionId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    message: {\n      list: async (sessionId, opts) => {\n        try {\n          return await rpc(\"message.list\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      get: async (id) => {\n        try {\n          const result = await rpc(\"message.get\", { id });\n          if (result === null) {\n            return new MessageNotFoundError({ id });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (message) => {\n        try {\n          return await rpc(\"message.set\", message);\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    part: {\n      listByMessage: async (messageId, opts) => {\n        try {\n          const result = await rpc(\"part.listByMessage\", {\n            messageId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      listBySession: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"part.listBySession\", {\n            sessionId,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Part>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (part) => {\n        try {\n          return (await rpc(\"part.set\", part)) as Part;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      delete: async (id) => {\n        try {\n          await rpc(\"part.delete\", { id });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n    sandbox: {\n      get: async (key) => {\n        try {\n          const result = await rpc(\"sandbox.get\", { key });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: key });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      getBySession: async (sessionId) => {\n        try {\n          const result = await rpc(\"sandbox.getBySession\", { sessionId });\n          if (result === null) {\n            return new SandboxNotFoundError({ id: sessionId });\n          }\n          return result;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (record) => {\n        try {\n          await rpc(\"sandbox.set\", record);\n          return record;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (opts) => {\n        try {\n          return await rpc(\"sandbox.list\", {\n            tags: opts?.tags,\n            order: opts?.order,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      tag: {\n        set: async ({ sandboxId, tags }) => {\n          try {\n            return await rpc(\"sandbox.tag.set\", { sandboxId, tags });\n          } catch (e) {\n            if (e instanceof StorageError) {\n              return e;\n            }\n            return new StorageError({ reason: String(e), cause: e });\n          }\n        },\n      },\n    },\n    command: {\n      get: async (id) => {\n        try {\n          return (await rpc(\"command.get\", { id })) as Command | null;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      set: async (command) => {\n        try {\n          return (await rpc(\"command.set\", command)) as Command;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n      list: async (sessionId, opts) => {\n        try {\n          const result = await rpc(\"command.list\", {\n            sessionId,\n            includeFinished: opts?.includeFinished,\n            cursor: opts?.cursor,\n            limit: opts?.limit,\n          });\n          return result as ListResult<Command>;\n        } catch (e) {\n          if (e instanceof StorageError) {\n            return e;\n          }\n          return new StorageError({ reason: String(e), cause: e });\n        }\n      },\n    },\n  };\n}\n\nexport const DEFAULT_NAMESPACE = \"default\";\nexport const LOCAL_STORAGE_VERSION = \"v1\";\n\nexport function getStorage(opts: {\n  config: StorageConfig;\n  rpc: RpcFn;\n}): Storage {\n  const name = opts.config.name ?? DEFAULT_NAMESPACE;\n  return getStorageClient(opts.rpc, name);\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/chunk-HJGPUEFC.mjs

@@ -0,0 +1,42 @@
+// src/errors.ts
+import * as errore from "errore";
+var SessionNotFoundError = class extends errore.createTaggedError({
+  name: "SessionNotFoundError",
+  message: "Session $id not found"
+}) {
+};
+var SessionError = class extends errore.createTaggedError({
+  name: "SessionError",
+  message: "Session $id failed: $reason"
+}) {
+};
+var SandboxNotFoundError = class extends errore.createTaggedError({
+  name: "SandboxNotFoundError",
+  message: "Sandbox $id not found"
+}) {
+};
+var StorageError = class extends errore.createTaggedError({
+  name: "StorageError",
+  message: "$reason"
+}) {
+};
+var SandboxError = class extends errore.createTaggedError({
+  name: "SandboxError",
+  message: "$reason"
+}) {
+};
+var MessageNotFoundError = class extends errore.createTaggedError({
+  name: "MessageNotFoundError",
+  message: "Message $id not found"
+}) {
+};
+
+export {
+  SessionNotFoundError,
+  SessionError,
+  SandboxNotFoundError,
+  StorageError,
+  SandboxError,
+  MessageNotFoundError
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vc3JjL2Vycm9ycy50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiaW1wb3J0ICogYXMgZXJyb3JlIGZyb20gXCJlcnJvcmVcIjtcblxuZXhwb3J0IGNsYXNzIFNlc3Npb25Ob3RGb3VuZEVycm9yIGV4dGVuZHMgZXJyb3JlLmNyZWF0ZVRhZ2dlZEVycm9yKHtcbiAgbmFtZTogXCJTZXNzaW9uTm90Rm91bmRFcnJvclwiLFxuICBtZXNzYWdlOiBcIlNlc3Npb24gJGlkIG5vdCBmb3VuZFwiLFxufSkge31cblxuZXhwb3J0IGNsYXNzIFNlc3Npb25FcnJvciBleHRlbmRzIGVycm9yZS5jcmVhdGVUYWdnZWRFcnJvcih7XG4gIG5hbWU6IFwiU2Vzc2lvbkVycm9yXCIsXG4gIG1lc3NhZ2U6IFwiU2Vzc2lvbiAkaWQgZmFpbGVkOiAkcmVhc29uXCIsXG59KSB7fVxuXG5leHBvcnQgY2xhc3MgU2FuZGJveE5vdEZvdW5kRXJyb3IgZXh0ZW5kcyBlcnJvcmUuY3JlYXRlVGFnZ2VkRXJyb3Ioe1xuICBuYW1lOiBcIlNhbmRib3hOb3RGb3VuZEVycm9yXCIsXG4gIG1lc3NhZ2U6IFwiU2FuZGJveCAkaWQgbm90IGZvdW5kXCIsXG59KSB7fVxuXG5leHBvcnQgY2xhc3MgU3RvcmFnZUVycm9yIGV4dGVuZHMgZXJyb3JlLmNyZWF0ZVRhZ2dlZEVycm9yKHtcbiAgbmFtZTogXCJTdG9yYWdlRXJyb3JcIixcbiAgbWVzc2FnZTogXCIkcmVhc29uXCIsXG59KSB7fVxuXG5leHBvcnQgY2xhc3MgU2FuZGJveEVycm9yIGV4dGVuZHMgZXJyb3JlLmNyZWF0ZVRhZ2dlZEVycm9yKHtcbiAgbmFtZTogXCJTYW5kYm94RXJyb3JcIixcbiAgbWVzc2FnZTogXCIkcmVhc29uXCIsXG59KSB7fVxuXG5leHBvcnQgY2xhc3MgTWVzc2FnZU5vdEZvdW5kRXJyb3IgZXh0ZW5kcyBlcnJvcmUuY3JlYXRlVGFnZ2VkRXJyb3Ioe1xuICBuYW1lOiBcIk1lc3NhZ2VOb3RGb3VuZEVycm9yXCIsXG4gIG1lc3NhZ2U6IFwiTWVzc2FnZSAkaWQgbm90IGZvdW5kXCIsXG59KSB7fVxuIl0sCiAgIm1hcHBpbmdzIjogIjtBQUFBLFlBQVksWUFBWTtBQUVqQixJQUFNLHVCQUFOLGNBQTBDLHlCQUFrQjtBQUFBLEVBQ2pFLE1BQU07QUFBQSxFQUNOLFNBQVM7QUFDWCxDQUFDLEVBQUU7QUFBQztBQUVHLElBQU0sZUFBTixjQUFrQyx5QkFBa0I7QUFBQSxFQUN6RCxNQUFNO0FBQUEsRUFDTixTQUFTO0FBQ1gsQ0FBQyxFQUFFO0FBQUM7QUFFRyxJQUFNLHVCQUFOLGNBQTBDLHlCQUFrQjtBQUFBLEVBQ2pFLE1BQU07QUFBQSxFQUNOLFNBQVM7QUFDWCxDQUFDLEVBQUU7QUFBQztBQUVHLElBQU0sZUFBTixjQUFrQyx5QkFBa0I7QUFBQSxFQUN6RCxNQUFNO0FBQUEsRUFDTixTQUFTO0FBQ1gsQ0FBQyxFQUFFO0FBQUM7QUFFRyxJQUFNLGVBQU4sY0FBa0MseUJBQWtCO0FBQUEsRUFDekQsTUFBTTtBQUFBLEVBQ04sU0FBUztBQUNYLENBQUMsRUFBRTtBQUFDO0FBRUcsSUFBTSx1QkFBTixjQUEwQyx5QkFBa0I7QUFBQSxFQUNqRSxNQUFNO0FBQUEsRUFDTixTQUFTO0FBQ1gsQ0FBQyxFQUFFO0FBQUM7IiwKICAibmFtZXMiOiBbXQp9Cg==