@kaoruisaac/pedelec 0.4.6 → 0.4.8

package/README.md

@@ -286,6 +286,17 @@ console.log(session.workspace.path); // null for managed Workspace
 
 `workspace.listFiles(path?)` and `workspace.listFolders(path?)` recursively return Workspace-relative paths. An omitted path lists from the Workspace root; `/` is the separator and results are lexicographically sorted. The `.pedelec-runtime` directory is included. Symlinks and junctions are neither followed nor returned. Results are not silently truncated: an oversized response fails with `WORKSPACE_LIST_TOO_LARGE`, so retry with a narrower path.
 
+`workspace.uploadFile(file, targetPath?)` and `workspace.readFile(path, type)` transfer regular files anywhere in the Workspace, including `.pedelec-runtime`. Paths are Workspace-relative, use `/`, and do not start with `/`. `uploadFile(file)` stores the original filename at the Workspace root and does not add a generated prefix. The limit is 100 MiB. Workspace uploads may run concurrently; shared filesystem conflicts remain the application's responsibility. `readFile()` accepts `"text"`, `"json"`, or `"file"`.
+
+```ts
+const workspace = await pedelec.openWorkspace("C:\\workspace\\project");
+const file = new File(["hello"], "hello.txt", { type: "text/plain" });
+const path = await workspace.uploadFile(file, "references/photo.png");
+const text = await workspace.readFile("README.md", "text");
+```
+
+`session.uploadAsset()`, `readAsset()`, and `listAssets()` stay available as Session-scoped conveniences. Their root is `.pedelec-runtime/assets`, which suits provider artifacts and Agent-shared assets. Use the Workspace methods for general filesystem access.
+
 `workspace.run(script, options?)` executes application-supplied Deno code in the Workspace:
 
 ```ts

package/dist/index.d.ts

@@ -9,7 +9,8 @@ export type JsonValue = JsonPrimitive | JsonValue[] | {
     [key: string]: JsonValue;
 };
 export type AssetPath = `/${string}`;
-export type ReadAssetType = "text" | "json" | "file";
+export type ReadFileType = "text" | "json" | "file";
+export type ReadAssetType = ReadFileType;
 export type Asset = {
     name: string;
     path: AssetPath;
@@ -361,6 +362,11 @@ export declare class PedelecWorkspace {
     createSession<const TTools extends readonly ToolDefinition[]>(input: CreateSessionInput<TTools>): Promise<PedelecSession<ToolNameOf<TTools>>>;
     listFiles(path?: string): Promise<string[]>;
     listFolders(path?: string): Promise<string[]>;
+    uploadFile(file: File): Promise<string>;
+    uploadFile(file: File, targetPath: string): Promise<string>;
+    readFile(path: string, type: "text"): Promise<string>;
+    readFile<T = JsonValue>(path: string, type: "json"): Promise<T>;
+    readFile(path: string, type: "file"): Promise<File>;
     run(script: string, options?: WorkspaceRunOptions): Promise<WorkspaceRunResult>;
     /** @internal */
     get workspaceIdInternal(): string;

package/dist/index.js

@@ -31,6 +31,118 @@ function isValidAssetPath(path) {
     return typeof path === "string" && /^\/(?:[^/\\\x00-\x1f]+)(?:\/[^/\\\x00-\x1f]+)*$/.test(path) &&
         path.split("/").every((part, index) => index === 0 || (part !== "." && part !== ".."));
 }
+function isValidWorkspaceFilePath(path) {
+    return typeof path === "string" &&
+        /^(?:[^/\\:\x00-\x1f]+)(?:\/[^/\\:\x00-\x1f]+)*$/.test(path) &&
+        path.split("/").every((part) => part !== "." && part !== "..");
+}
+function isReadFileType(type) {
+    return type === "text" || type === "json" || type === "file";
+}
+function rejectBrowserFile(file, message) {
+    if (typeof File === "undefined" || !(file instanceof File) || !file.name || file.size < 0) {
+        return makeError("INVALID_INPUT", message);
+    }
+    return null;
+}
+function uploadBrowserFile(client, request) {
+    return client.request(request.type, request.payload).then(async (ticket) => {
+        if (!ticket?.uploadUrl || !ticket.token) {
+            throw makeError("SDK_PROTOCOL_ERROR", "file upload ticket was invalid");
+        }
+        let response;
+        try {
+            response = await fetch(ticket.uploadUrl, {
+                method: "PUT",
+                headers: {
+                    Authorization: `Bearer ${ticket.token}`,
+                    "Content-Type": request.file.type || "application/octet-stream",
+                },
+                body: request.file,
+                credentials: "omit",
+            });
+        }
+        catch (error) {
+            throw normalizeError(error, request.failedCode, request.failedMessage);
+        }
+        let payload = null;
+        try {
+            payload = await response.json();
+        }
+        catch {
+            // normalized below
+        }
+        if (!response.ok) {
+            throw normalizeError(payload?.error, request.failedCode, request.failedMessage);
+        }
+        if (!request.acceptPath(payload?.path)) {
+            throw makeError("SDK_PROTOCOL_ERROR", "file upload response had an invalid path");
+        }
+        if (request.expectedPath !== undefined && payload?.path !== request.expectedPath) {
+            throw makeError("SDK_PROTOCOL_ERROR", "file upload response path did not match target path");
+        }
+        return payload?.path;
+    });
+}
+function downloadBrowserFile(client, request) {
+    return client.request(request.type, request.payload).then(async (ticket) => {
+        if (!ticket || typeof ticket !== "object") {
+            throw makeError("SDK_PROTOCOL_ERROR", "file download ticket was invalid");
+        }
+        const value = ticket;
+        if (typeof value.downloadUrl !== "string" ||
+            typeof value.token !== "string" ||
+            typeof value.name !== "string" ||
+            typeof value.mimeType !== "string" ||
+            typeof value.modifiedAt !== "number" ||
+            !Number.isFinite(value.modifiedAt) ||
+            !request.acceptPath(value.path)) {
+            throw makeError("SDK_PROTOCOL_ERROR", "file download ticket was invalid");
+        }
+        let response;
+        try {
+            response = await fetch(value.downloadUrl, {
+                headers: { Authorization: `Bearer ${value.token}` },
+                credentials: "omit",
+            });
+        }
+        catch (error) {
+            throw normalizeError(error, request.failedCode, request.failedMessage);
+        }
+        if (!response.ok) {
+            let payload;
+            try {
+                payload = await response.json();
+            }
+            catch {
+                // normalize below
+            }
+            throw normalizeError(payload?.error, request.failedCode, request.failedMessage);
+        }
+        const bytes = await response.arrayBuffer();
+        if (request.readType === "file") {
+            return new File([bytes], value.name, {
+                type: value.mimeType || "application/octet-stream",
+                lastModified: value.modifiedAt,
+            });
+        }
+        let text;
+        try {
+            text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw makeError(request.textDecodeCode, request.textDecodeMessage);
+        }
+        if (request.readType === "text")
+            return text;
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            throw makeError(request.invalidJsonCode, request.invalidJsonMessage);
+        }
+    });
+}
 const MAX_ASSET_UPLOAD_BYTES = 100 * 1024 * 1024;
 const TOOL_NAME_PATTERN = /^[a-zA-Z][a-zA-Z0-9_.-]*$/;
 export function defineTool(tool) {
@@ -251,6 +363,52 @@ export class PedelecWorkspace {
     listFolders(path) {
         return this.list("workspace_list_folders", path);
     }
+    uploadFile(file, targetPath) {
+        const invalidFile = rejectBrowserFile(file, "uploadFile requires a browser File with a filename");
+        if (invalidFile)
+            return Promise.reject(invalidFile);
+        if (file.size > MAX_ASSET_UPLOAD_BYTES) {
+            return Promise.reject(makeError("WORKSPACE_FILE_TOO_LARGE", "workspace file exceeds the 100 MiB limit"));
+        }
+        if (targetPath !== undefined && !isValidWorkspaceFilePath(targetPath)) {
+            return Promise.reject(makeError("WORKSPACE_PATH_INVALID", "workspace target path is invalid"));
+        }
+        if (targetPath === undefined && !isValidWorkspaceFilePath(file.name)) {
+            return Promise.reject(makeError("WORKSPACE_PATH_INVALID", "workspace filename is invalid"));
+        }
+        return uploadBrowserFile(this.client, {
+            type: "create_workspace_file_upload",
+            payload: {
+                workspaceId: this.workspaceId,
+                filename: file.name,
+                sizeBytes: file.size,
+                mimeType: file.type,
+                ...(targetPath === undefined ? {} : { targetPath }),
+            },
+            file,
+            expectedPath: targetPath ?? file.name,
+            acceptPath: isValidWorkspaceFilePath,
+            failedCode: "WORKSPACE_FILE_UPLOAD_FAILED",
+            failedMessage: "workspace file upload failed",
+        });
+    }
+    readFile(path, type) {
+        if (!isValidWorkspaceFilePath(path) || !isReadFileType(type)) {
+            return Promise.reject(makeError("WORKSPACE_PATH_INVALID", "workspace path or read type is invalid"));
+        }
+        return downloadBrowserFile(this.client, {
+            type: "create_workspace_file_download",
+            payload: { workspaceId: this.workspaceId, path },
+            readType: type,
+            acceptPath: isValidWorkspaceFilePath,
+            failedCode: "WORKSPACE_FILE_READ_FAILED",
+            failedMessage: "workspace file read failed",
+            textDecodeCode: "WORKSPACE_FILE_TEXT_DECODE_FAILED",
+            textDecodeMessage: "workspace file is not valid UTF-8",
+            invalidJsonCode: "WORKSPACE_FILE_INVALID_JSON",
+            invalidJsonMessage: "workspace file does not contain valid JSON",
+        });
+    }
     run(script, options = {}) {
         if (typeof script !== "string") {
             return Promise.reject(makeError("INVALID_INPUT", "script must be a string"));
@@ -1109,39 +1267,28 @@ export class PedelecSession {
         if (this.uploadPromise) {
             return Promise.reject(makeError("SESSION_BUSY", "session is busy", { sessionId: this.sessionId }));
         }
-        if (typeof File === "undefined" || !(file instanceof File) || !file.name || file.size < 0) {
-            return Promise.reject(makeError("INVALID_INPUT", "uploadAsset requires a browser File with a filename"));
-        }
+        const invalidFile = rejectBrowserFile(file, "uploadAsset requires a browser File with a filename");
+        if (invalidFile)
+            return Promise.reject(invalidFile);
         if (file.size > MAX_ASSET_UPLOAD_BYTES)
             return Promise.reject(makeError("ASSET_TOO_LARGE", "asset exceeds the 100 MiB limit"));
         if (targetPath !== undefined && !isValidAssetPath(targetPath))
             return Promise.reject(makeError("ASSET_PATH_INVALID", "asset target path is invalid"));
-        this.uploadPromise = this.client.request("create_asset_upload", {
-            sessionId: this.sessionId, filename: file.name, sizeBytes: file.size, mimeType: file.type,
-            ...(targetPath === undefined ? {} : { targetPath }),
-        }).then(async (ticket) => {
-            if (!ticket?.uploadUrl || !ticket.token)
-                throw makeError("SDK_PROTOCOL_ERROR", "asset upload ticket was invalid");
-            let response;
-            try {
-                response = await fetch(ticket.uploadUrl, { method: "PUT", headers: { Authorization: `Bearer ${ticket.token}`, "Content-Type": file.type || "application/octet-stream" }, body: file, credentials: "omit" });
-            }
-            catch (error) {
-                throw normalizeError(error, "ASSET_UPLOAD_FAILED", "asset upload failed");
-            }
-            let payload = null;
-            try {
-                payload = await response.json();
-            }
-            catch { /* normalized below */ }
-            if (!response.ok)
-                throw normalizeError(payload?.error, "ASSET_UPLOAD_FAILED", "asset upload failed");
-            if (!isValidAssetPath(payload?.path))
-                throw makeError("SDK_PROTOCOL_ERROR", "asset upload response had an invalid path");
-            if (targetPath !== undefined && payload.path !== targetPath)
-                throw makeError("SDK_PROTOCOL_ERROR", "asset upload response path did not match target path");
-            return payload.path;
-        }).finally(() => { this.uploadPromise = null; });
+        this.uploadPromise = uploadBrowserFile(this.client, {
+            type: "create_asset_upload",
+            payload: {
+                sessionId: this.sessionId,
+                filename: file.name,
+                sizeBytes: file.size,
+                mimeType: file.type,
+                ...(targetPath === undefined ? {} : { targetPath }),
+            },
+            file,
+            expectedPath: targetPath,
+            acceptPath: isValidAssetPath,
+            failedCode: "ASSET_UPLOAD_FAILED",
+            failedMessage: "asset upload failed",
+        }).then((path) => path).finally(() => { this.uploadPromise = null; });
         return this.uploadPromise;
     }
     listAssets() {
@@ -1153,50 +1300,20 @@ export class PedelecSession {
     readAsset(path, type) {
         if (this.transportDetached || this.ending || this.status === "ended")
             return Promise.reject(makeError("SESSION_ENDED", "session has ended", { sessionId: this.sessionId }));
-        if (!isValidAssetPath(path) || !["text", "json", "file"].includes(type)) {
+        if (!isValidAssetPath(path) || !isReadFileType(type)) {
             return Promise.reject(makeError("ASSET_PATH_INVALID", "asset path or read type is invalid"));
         }
-        return this.client.request("create_asset_download", { sessionId: this.sessionId, path }).then(async (ticket) => {
-            if (!ticket || typeof ticket !== "object")
-                throw makeError("SDK_PROTOCOL_ERROR", "asset download ticket was invalid");
-            const value = ticket;
-            if (typeof value.downloadUrl !== "string" || typeof value.token !== "string" || typeof value.name !== "string" ||
-                typeof value.mimeType !== "string" || typeof value.modifiedAt !== "number" || !Number.isFinite(value.modifiedAt) || !isValidAssetPath(value.path)) {
-                throw makeError("SDK_PROTOCOL_ERROR", "asset download ticket was invalid");
-            }
-            let response;
-            try {
-                response = await fetch(value.downloadUrl, { headers: { Authorization: `Bearer ${value.token}` }, credentials: "omit" });
-            }
-            catch (error) {
-                throw normalizeError(error, "ASSET_READ_FAILED", "asset read failed");
-            }
-            if (!response.ok) {
-                let payload;
-                try {
-                    payload = await response.json();
-                }
-                catch { /* normalize below */ }
-                throw normalizeError(payload?.error, "ASSET_READ_FAILED", "asset read failed");
-            }
-            const bytes = await response.arrayBuffer();
-            if (type === "file")
-                return new File([bytes], value.name, { type: value.mimeType || "application/octet-stream", lastModified: value.modifiedAt });
-            let text;
-            try {
-                text = new TextDecoder("utf-8", { fatal: true }).decode(bytes);
-            }
-            catch {
-                throw makeError("ASSET_TEXT_DECODE_FAILED", "asset is not valid UTF-8");
-            }
-            if (type === "text")
-                return text;
-            try {
-                return JSON.parse(text);
-            }
-            catch {
-                throw makeError("ASSET_INVALID_JSON", "asset does not contain valid JSON");
-            }
+        return downloadBrowserFile(this.client, {
+            type: "create_asset_download",
+            payload: { sessionId: this.sessionId, path },
+            readType: type,
+            acceptPath: isValidAssetPath,
+            failedCode: "ASSET_READ_FAILED",
+            failedMessage: "asset read failed",
+            textDecodeCode: "ASSET_TEXT_DECODE_FAILED",
+            textDecodeMessage: "asset is not valid UTF-8",
+            invalidJsonCode: "ASSET_INVALID_JSON",
+            invalidJsonMessage: "asset does not contain valid JSON",
         });
     }
     onError(handler) {

package/dist/index.type-test.js

@@ -251,6 +251,20 @@ async function workspacePublicTypeContract() {
     // @ts-expect-error the removed picker API must not be public
     pedelec.workspaceFolderPicker();
 }
+async function workspaceFileTransferTypes() {
+    const pedelec = new Pedelec();
+    const workspace = await pedelec.openWorkspace("C:\\workspace\\project");
+    const file = new File(["hello"], "hello.txt", { type: "text/plain" });
+    const generated = await workspace.uploadFile(file);
+    const nested = await workspace.uploadFile(file, "references/photo.png");
+    const text = await workspace.readFile("README.md", "text");
+    const parsed = await workspace.readFile("result.json", "json");
+    const downloaded = await workspace.readFile(generated, "file");
+    void nested;
+    void text;
+    void parsed;
+    void downloaded;
+}
 function directoryPickerIsRemoved() {
     const pedelec = new Pedelec();
     // @ts-expect-error directoryPicker was removed in favor of openWorkspace
@@ -277,6 +291,7 @@ void effortLevelPublicTypeContract;
 void listAssetsHasPublicTypes;
 void availabilityHasPublicType;
 void workspacePublicTypeContract;
+void workspaceFileTransferTypes;
 void directoryPickerIsRemoved;
 void publicSecurityTypesAreRestricted;
 const baseContext = {

package/dist/version.generated.d.ts

@@ -1 +1 @@
-export declare const SDK_VERSION = "0.4.6";
+export declare const SDK_VERSION = "0.4.8";

package/dist/version.generated.js

@@ -1,2 +1,2 @@
 // Generated from sdk/package.json. Do not edit manually.
-export const SDK_VERSION = "0.4.6";
+export const SDK_VERSION = "0.4.8";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kaoruisaac/pedelec",
-  "version": "0.4.6",
+  "version": "0.4.8",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",