@axiom-lattice/core 2.1.88 → 2.1.90

package/dist/index.mjs

@@ -5741,7 +5741,8 @@ var VolumeFilesystem = class {
     }).join("\n");
   }
   async readRaw(filePath) {
-    const content = await this.client.read(filePath);
+    const buf = await this.client.readRaw(filePath);
+    const content = buf.toString("utf-8");
     const lines = content.split("\n");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     return {
@@ -5750,6 +5751,12 @@ var VolumeFilesystem = class {
       modified_at: now
     };
   }
+  async readBinary(filePath) {
+    return this.client.readRaw(filePath);
+  }
+  async writeBinary(filePath, data) {
+    await this.client.writeRaw(filePath, data);
+  }
   grepRaw(_pattern, _path, _glob) {
     throw new Error("Not supported on volume backend");
   }
@@ -5984,6 +5991,17 @@ var SandboxLatticeManager = class _SandboxLatticeManager extends BaseLatticeMana
     }
     return provider;
   }
+  /**
+   * Returns the first registered (default) sandbox provider.
+   *
+   * Used by the resource sharing system for file resolution
+   * when a specific provider key is not specified.
+   *
+   * @returns The default registered {@link SandboxProvider}.
+   */
+  getDefaultProvider() {
+    return this._requireProvider();
+  }
 };
 var sandboxLatticeManager = SandboxLatticeManager.getInstance();
 var getSandBoxManager = (key = "default") => {
@@ -22627,6 +22645,12 @@ var MicrosandboxServiceClient = class {
   }
 };
 
+// src/sandbox_lattice/resourceAddressUtils.ts
+function createResourceAddress(config) {
+  const volume = buildNamedVolumeName("p", "project", config.tenantId, config.workspaceId, config.projectId);
+  return { volume, resourcePath: config.resourcePath };
+}
+
 // src/sandbox_lattice/providers/MicrosandboxRemoteProvider.ts
 function parseOptionalNumberEnv(name, fallback) {
   const rawValue = process.env[name];
@@ -22652,6 +22676,7 @@ var MicrosandboxRemoteProvider = class {
   constructor(config) {
     this.config = config;
     this.creating = /* @__PURE__ */ new Map();
+    this.createResourceAddress = createResourceAddress;
     this.client = config.client ?? new MicrosandboxServiceClient({
       baseURL: config.baseURL,
       apiKey: config.apiKey ?? process.env.MICROSANDBOX_API_KEY
@@ -22702,6 +22727,13 @@ var MicrosandboxRemoteProvider = class {
   async listSandboxes() {
     return [];
   }
+  getResourceResolver() {
+    return {
+      resolve: async (address) => {
+        return this.client.volumeFsDownload(address.volume, `/project/${address.resourcePath}`);
+      }
+    };
+  }
   buildEnsureInput(config) {
     const defaultMicrosandboxRemoteConfig = getDefaultMicrosandboxRemoteConfig();
     const image = this.config.image ?? defaultMicrosandboxRemoteConfig.image;
@@ -22937,6 +22969,7 @@ var RemoteSandboxProvider = class {
     this.creating = /* @__PURE__ */ new Map();
     this.workspace = DEFAULT_WORKSPACE;
     this.workspaceResolved = false;
+    this.createResourceAddress = createResourceAddress;
     this.client = new SandboxClient23({
       baseUrl: config.baseURL,
       environment: ""
@@ -22998,6 +23031,14 @@ var RemoteSandboxProvider = class {
   async listSandboxes() {
     return Array.from(this.instances.values());
   }
+  getResourceResolver() {
+    return {
+      resolve: async (address) => {
+        const client = this.createVolumeFsClient(address.volume, `/project`);
+        return client.readRaw(address.resourcePath);
+      }
+    };
+  }
   createVolumeFsClient(_volumeName, pathPrefix) {
     const workspace = this.workspace;
     const resolve4 = (p) => {
@@ -23189,6 +23230,7 @@ var E2BProvider = class {
     this.config = config;
     this.instances = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
+    this.createResourceAddress = createResourceAddress;
   }
   async createSandbox(name, _config) {
     const existing = this.instances.get(name);
@@ -23246,6 +23288,16 @@ var E2BProvider = class {
   async listSandboxes() {
     return Array.from(this.instances.values());
   }
+  getResourceResolver() {
+    const instances = this.instances;
+    return {
+      resolve: async (address) => {
+        const entry = Array.from(instances.values())[0];
+        if (!entry) throw new Error("No sandbox instance available to resolve resource");
+        return entry.file.downloadFile({ file: `/project/${address.resourcePath}` });
+      }
+    };
+  }
 };
 
 // src/sandbox_lattice/providers/DaytonaProvider.ts
@@ -23373,6 +23425,7 @@ var DaytonaProvider = class {
     this.instances = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
     this.volumeId = null;
+    this.createResourceAddress = createResourceAddress;
     this.daytona = new Daytona({
       apiKey: config.apiKey,
       apiUrl: config.apiUrl,
@@ -23557,11 +23610,22 @@ var DaytonaProvider = class {
   async listSandboxes() {
     return Array.from(this.instances.values());
   }
+  getResourceResolver() {
+    const instances = this.instances;
+    return {
+      resolve: async (address) => {
+        const entry = Array.from(instances.values())[0];
+        if (!entry) throw new Error("No sandbox instance available to resolve resource");
+        return entry.file.downloadFile({ file: `/project/${address.resourcePath}` });
+      }
+    };
+  }
 };
 
 // src/sandbox_lattice/providers/LocalSandboxProvider.ts
 import * as path4 from "path";
 import * as os from "os";
+import * as fs4 from "fs/promises";
 
 // src/sandbox_lattice/LocalSandboxInstance.ts
 import { execFile } from "child_process";
@@ -23776,6 +23840,7 @@ var LocalSandboxProvider = class {
   constructor(config = {}) {
     this.instances = /* @__PURE__ */ new Map();
     this.creating = /* @__PURE__ */ new Map();
+    this.createResourceAddress = createResourceAddress;
     this.basePath = config.basePath ?? path4.join(os.homedir(), ".axiom-local-sandbox");
   }
   async createSandbox(name, _config) {
@@ -23828,6 +23893,14 @@ var LocalSandboxProvider = class {
   async listSandboxes() {
     return Array.from(this.instances.values());
   }
+  getResourceResolver() {
+    return {
+      resolve: async (address) => {
+        const hostPath = path4.join(this.basePath, "project", address.resourcePath);
+        return fs4.readFile(hostPath);
+      }
+    };
+  }
 };
 
 // src/sandbox_lattice/SandboxProviderFactory.ts
@@ -23884,6 +23957,75 @@ function createSandboxProvider(config) {
   }
 }
 
+// src/sandbox_lattice/TokenCache.ts
+var TokenCache = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.ttlMs = 6e4;
+  }
+  /**
+   * Look up a token in the cache.
+   *
+   * @param token - The share token.
+   * @returns The cached entry, or `null` if the token is absent or expired.
+   */
+  get(token) {
+    const item = this.cache.get(token);
+    if (!item) return null;
+    if (Date.now() > item.expires) {
+      this.cache.delete(token);
+      return null;
+    }
+    return item.entry;
+  }
+  /**
+   * Store a token → address mapping.
+   *
+   * @param token - The share token.
+   * @param entry - The cache entry to associate with the token.
+   */
+  set(token, entry) {
+    this.cache.set(token, { entry, expires: Date.now() + this.ttlMs });
+  }
+  /**
+   * Remove a cached entry (e.g. on revocation).
+   *
+   * @param token - The share token to invalidate.
+   */
+  invalidate(token) {
+    this.cache.delete(token);
+  }
+};
+
+// src/sandbox_lattice/ShareService.ts
+import { randomBytes } from "crypto";
+var TOKEN_BYTES = 24;
+function generateToken() {
+  return randomBytes(TOKEN_BYTES).toString("base64url");
+}
+function createSharePayload(tenantId, workspaceId, projectId, userId, request) {
+  return {
+    address: createResourceAddress({
+      tenantId,
+      workspaceId,
+      projectId,
+      resourcePath: request.resourcePath
+    }),
+    tenantId,
+    workspaceId,
+    projectId,
+    assistantId: request.assistantId ?? null,
+    vmIsolation: "project",
+    visibility: request.visibility ?? "public",
+    passwordHash: request.visibility === "password" && request.password ? request.password : null,
+    title: request.title ?? null,
+    createdBy: userId,
+    expiresAt: request.expiresAt ? new Date(request.expiresAt) : null,
+    maxAccess: request.maxAccess ?? null,
+    revoked: false
+  };
+}
+
 // src/channel/connectAllChannels.ts
 async function connectAllChannels(getAdapter, options = {}) {
   const store = getStoreLattice("default", "channelInstallation").store;
@@ -23924,7 +24066,7 @@ function getMenuRegistry() {
 import * as Protocols from "@axiom-lattice/protocols";
 
 // src/util/encryption.ts
-import { createCipheriv, createDecipheriv, randomBytes, pbkdf2Sync } from "crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, pbkdf2Sync } from "crypto";
 var ALGORITHM = "aes-256-gcm";
 var IV_LENGTH = 16;
 var SALT_LENGTH = 32;
@@ -23946,8 +24088,8 @@ function getEncryptionKey() {
 }
 function encrypt(plaintext, key) {
   const actualKey = key || getEncryptionKey();
-  const salt = randomBytes(SALT_LENGTH);
-  const iv = randomBytes(IV_LENGTH);
+  const salt = randomBytes2(SALT_LENGTH);
+  const iv = randomBytes2(IV_LENGTH);
   const derivedKey = pbkdf2Sync(actualKey, salt, ITERATIONS, 32, "sha256");
   const cipher = createCipheriv(ALGORITHM, derivedKey, iv);
   const encrypted = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
@@ -24208,6 +24350,7 @@ export {
   TaskStatus,
   TeamAgentGraphBuilder,
   ThreadStatus2 as ThreadStatus,
+  TokenCache,
   ToolLatticeManager,
   VectorStoreLatticeManager,
   VolumeFilesystem,
@@ -24245,8 +24388,10 @@ export {
   createQuerySqlTool,
   createQueryTableDefinitionTool,
   createQueryTablesListTool,
+  createResourceAddress,
   createSandboxProvider,
   createSchedulerMiddleware,
+  createSharePayload,
   createTaskMiddleware,
   createTeamMiddleware,
   createTeammateTools,
@@ -24266,6 +24411,7 @@ export {
   formatGrepMatches,
   formatGrepResults,
   formatReadResponse,
+  generateToken,
   getAgentClient,
   getAgentConfig,
   getAllAgentConfigs,