@azatakmyradov/opencode-save-md-plugin 0.1.0 → 0.1.1

package/dist/core.d.ts

@@ -0,0 +1,39 @@
+import type { SessionMessage } from "@opencode-ai/schema/session-message";
+import { Effect, Schema } from "effect";
+declare const NoAssistantResponseError_base: Schema.Class<NoAssistantResponseError, Schema.TaggedStruct<"NoAssistantResponseError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NoAssistantResponseError extends NoAssistantResponseError_base {
+}
+declare const NoMarkdownTextError_base: Schema.Class<NoMarkdownTextError, Schema.TaggedStruct<"NoMarkdownTextError", {
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class NoMarkdownTextError extends NoMarkdownTextError_base {
+}
+declare const InvalidPathError_base: Schema.Class<InvalidPathError, Schema.TaggedStruct<"InvalidPathError", {
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class InvalidPathError extends InvalidPathError_base {
+}
+declare const DestinationExistsError_base: Schema.Class<DestinationExistsError, Schema.TaggedStruct<"DestinationExistsError", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class DestinationExistsError extends DestinationExistsError_base {
+}
+declare const FileSystemWriteError_base: Schema.Class<FileSystemWriteError, Schema.TaggedStruct<"FileSystemWriteError", {
+    readonly path: Schema.String;
+    readonly message: Schema.String;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class FileSystemWriteError extends FileSystemWriteError_base {
+}
+export type SaveMarkdownError = NoAssistantResponseError | NoMarkdownTextError | InvalidPathError | DestinationExistsError | FileSystemWriteError;
+export declare const selectLatestAssistant: (messages: readonly SessionMessage.Info[]) => Effect.Effect<SessionMessage.Assistant, NoAssistantResponseError, never>;
+export declare const extractMarkdown: (message: SessionMessage.Assistant) => Effect.Effect<string, NoMarkdownTextError, never>;
+export declare const extractLatestMarkdown: (messages: readonly SessionMessage.Info[]) => Effect.Effect<string, NoAssistantResponseError | NoMarkdownTextError, never>;
+export declare const resolveMarkdownPath: (directory: string, name: string) => Effect.Effect<string, InvalidPathError, never>;
+export declare const saveMarkdown: (directory: string, name: string, markdown: string) => Effect.Effect<string, InvalidPathError | DestinationExistsError | FileSystemWriteError, never>;
+export declare const saveLatestAssistant: (directory: string, name: string, messages: readonly SessionMessage.Info[]) => Effect.Effect<string, SaveMarkdownError, never>;
+export {};

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "@opencode-ai/plugin/effect";
+declare const _default: Plugin.Plugin<import("effect/Scope").Scope>;
+export default _default;

package/dist/index.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 var NoDetails = z.object({});
 var InvalidPathDetails = z.object({ name: z.string() });
 var DestinationDetails = z.object({ path: z.string() });
+var SessionFailureDetails = z.object({ operation: z.enum(["wait", "context"]) });
 var SaveMdRpc = Rpc.define({
   id: "save-md",
   methods: {
@@ -19,7 +20,8 @@ var SaveMdRpc = Rpc.define({
         no_markdown_text: NoDetails,
         invalid_path: InvalidPathDetails,
         destination_exists: DestinationDetails,
-        filesystem_write_failed: DestinationDetails
+        filesystem_write_failed: DestinationDetails,
+        session_failed: SessionFailureDetails
       }
     }
   },
@@ -38,16 +40,22 @@ var SaveMdRpcFailure = z.discriminatedUnion("type", [
     type: z.literal("filesystem_write_failed"),
     message: z.string(),
     data: DestinationDetails
+  }),
+  z.object({
+    type: z.literal("session_failed"),
+    message: z.string(),
+    data: SessionFailureDetails
   })
 ]);
+var RpcFailure = z.object({ type: z.string(), message: z.string() });
 
 // src/index.ts
-import { Effect as Effect2 } from "effect";
+import { Cause, Effect as Effect2, Schema as Schema2 } from "effect";
 import { Plugin } from "@opencode-ai/plugin/effect";
 
 // src/core.ts
-import { writeFile } from "fs/promises";
-import { isAbsolute, relative, resolve, sep, win32 } from "path";
+import { realpath, writeFile } from "fs/promises";
+import { dirname, isAbsolute, relative, resolve, sep, win32 } from "path";
 import { DateTime, Effect, Schema } from "effect";
 
 class NoAssistantResponseError extends Schema.TaggedError()("NoAssistantResponseError", { message: Schema.String }) {
@@ -76,6 +84,26 @@ class FileSystemWriteError extends Schema.TaggedError()("FileSystemWriteError",
 }
 var ExistingFileSystemError = Schema.Struct({ code: Schema.Literal("EEXIST") });
 var isExistingFileSystemError = Schema.is(ExistingFileSystemError);
+function writeFailure(path, cause) {
+  return new FileSystemWriteError({
+    path,
+    cause,
+    message: `Could not write Markdown to ${path}: ${cause instanceof Error ? cause.message : String(cause)}`
+  });
+}
+var validatePhysicalContainment = Effect.fn("validatePhysicalContainment")(function* (directory, destination, name) {
+  const [root, parent] = yield* Effect.tryPromise({
+    try: () => Promise.all([realpath(directory), realpath(dirname(destination))]),
+    catch: (cause) => writeFailure(destination, cause)
+  });
+  const contained = relative(root, parent);
+  if (contained === ".." || contained.startsWith(`..${sep}`) || isAbsolute(contained)) {
+    return yield* new InvalidPathError({
+      name,
+      message: "The destination path escapes the current location through a symbolic link."
+    });
+  }
+});
 var selectLatestAssistant = Effect.fn("selectLatestAssistant")(function* (messages) {
   let latest;
   for (const message of messages) {
@@ -130,6 +158,7 @@ var resolveMarkdownPath = Effect.fn("resolveMarkdownPath")(function* (directory,
 });
 var saveMarkdown = Effect.fn("saveMarkdown")(function* (directory, name, markdown) {
   const destination = yield* resolveMarkdownPath(directory, name);
+  yield* validatePhysicalContainment(resolve(directory), destination, name);
   const content = markdown.endsWith(`
 `) ? markdown : `${markdown}
 `;
@@ -146,11 +175,7 @@ var saveMarkdown = Effect.fn("saveMarkdown")(function* (directory, name, markdow
           message: `Destination already exists: ${destination}`
         });
       }
-      return new FileSystemWriteError({
-        path: destination,
-        cause,
-        message: `Could not write Markdown to ${destination}: ${cause instanceof Error ? cause.message : String(cause)}`
-      });
+      return writeFailure(destination, cause);
     }
   });
   return destination;
@@ -161,6 +186,24 @@ var saveLatestAssistant = Effect.fn("saveLatestAssistant")(function* (directory,
 });
 
 // src/index.ts
+class SessionAccessError extends Schema2.TaggedError()("SessionAccessError", {
+  operation: Schema2.Literals(["wait", "context"]),
+  message: Schema2.String,
+  cause: Schema2.Defect()
+}) {
+}
+function sessionOperation(operation, effect) {
+  return Effect2.catchCause(effect, (cause) => {
+    if (Cause.hasInterruptsOnly(cause))
+      return Effect2.interrupt;
+    const error = Cause.squash(cause);
+    return Effect2.fail(new SessionAccessError({
+      operation,
+      cause: error,
+      message: `Session ${operation} failed: ${error instanceof Error ? error.message : String(error)}`
+    }));
+  });
+}
 var src_default = Plugin.define({
   id: "save-md",
   effect: (ctx) => Effect2.gen(function* () {
@@ -168,8 +211,8 @@ var src_default = Plugin.define({
       save: ({ sessionID, name }, rpc) => {
         const id = sessionID;
         return Effect2.gen(function* () {
-          yield* ctx.session.wait({ sessionID: id }).pipe(Effect2.orDie);
-          const messages = yield* ctx.session.context({ sessionID: id }).pipe(Effect2.orDie);
+          yield* sessionOperation("wait", ctx.session.wait({ sessionID: id }));
+          const messages = yield* sessionOperation("context", ctx.session.context({ sessionID: id }));
           const path = yield* saveLatestAssistant(ctx.location.directory, name, messages);
           return { path };
         }).pipe(Effect2.catchTags({
@@ -177,7 +220,8 @@ var src_default = Plugin.define({
           NoMarkdownTextError: (error) => Effect2.fail(rpc.error("no_markdown_text", error.message, {})),
           InvalidPathError: (error) => Effect2.fail(rpc.error("invalid_path", error.message, { name: error.name })),
           DestinationExistsError: (error) => Effect2.fail(rpc.error("destination_exists", error.message, { path: error.path })),
-          FileSystemWriteError: (error) => Effect2.fail(rpc.error("filesystem_write_failed", error.message, { path: error.path }))
+          FileSystemWriteError: (error) => Effect2.fail(rpc.error("filesystem_write_failed", error.message, { path: error.path })),
+          SessionAccessError: (error) => Effect2.fail(rpc.error("session_failed", error.message, { operation: error.operation }))
         }));
       }
     }).pipe(Effect2.orDie);

package/dist/rpc.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+export declare const SaveMdRpc: {
+    readonly id: "save-md";
+    readonly methods: {
+        readonly save: {
+            readonly input: z.ZodObject<{
+                sessionID: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strip>;
+            readonly output: z.ZodObject<{
+                path: z.ZodString;
+            }, z.core.$strip>;
+            readonly errors: {
+                readonly no_assistant_response: z.ZodObject<{}, z.core.$strip>;
+                readonly no_markdown_text: z.ZodObject<{}, z.core.$strip>;
+                readonly invalid_path: z.ZodObject<{
+                    name: z.ZodString;
+                }, z.core.$strip>;
+                readonly destination_exists: z.ZodObject<{
+                    path: z.ZodString;
+                }, z.core.$strip>;
+                readonly filesystem_write_failed: z.ZodObject<{
+                    path: z.ZodString;
+                }, z.core.$strip>;
+                readonly session_failed: z.ZodObject<{
+                    operation: z.ZodEnum<{
+                        wait: "wait";
+                        context: "context";
+                    }>;
+                }, z.core.$strip>;
+            };
+        };
+    };
+    readonly events: {};
+};
+export declare const SaveMdRpcFailure: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"no_assistant_response">;
+    message: z.ZodString;
+    data: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"no_markdown_text">;
+    message: z.ZodString;
+    data: z.ZodObject<{}, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"invalid_path">;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        name: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"destination_exists">;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"filesystem_write_failed">;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        path: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"session_failed">;
+    message: z.ZodString;
+    data: z.ZodObject<{
+        operation: z.ZodEnum<{
+            wait: "wait";
+            context: "context";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export declare const RpcFailure: z.ZodObject<{
+    type: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>;

package/dist/rpc.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 var NoDetails = z.object({});
 var InvalidPathDetails = z.object({ name: z.string() });
 var DestinationDetails = z.object({ path: z.string() });
+var SessionFailureDetails = z.object({ operation: z.enum(["wait", "context"]) });
 var SaveMdRpc = Rpc.define({
   id: "save-md",
   methods: {
@@ -19,7 +20,8 @@ var SaveMdRpc = Rpc.define({
         no_markdown_text: NoDetails,
         invalid_path: InvalidPathDetails,
         destination_exists: DestinationDetails,
-        filesystem_write_failed: DestinationDetails
+        filesystem_write_failed: DestinationDetails,
+        session_failed: SessionFailureDetails
       }
     }
   },
@@ -38,9 +40,16 @@ var SaveMdRpcFailure = z.discriminatedUnion("type", [
     type: z.literal("filesystem_write_failed"),
     message: z.string(),
     data: DestinationDetails
+  }),
+  z.object({
+    type: z.literal("session_failed"),
+    message: z.string(),
+    data: SessionFailureDetails
   })
 ]);
+var RpcFailure = z.object({ type: z.string(), message: z.string() });
 export {
+  RpcFailure,
   SaveMdRpc,
   SaveMdRpcFailure
 };

package/dist/tui.d.ts

@@ -0,0 +1,3 @@
+import { Plugin } from "@opencode-ai/plugin/tui";
+declare const _default: Plugin.Definition;
+export default _default;

package/dist/tui.js

@@ -5,6 +5,7 @@ import { z } from "zod";
 var NoDetails = z.object({});
 var InvalidPathDetails = z.object({ name: z.string() });
 var DestinationDetails = z.object({ path: z.string() });
+var SessionFailureDetails = z.object({ operation: z.enum(["wait", "context"]) });
 var SaveMdRpc = Rpc.define({
   id: "save-md",
   methods: {
@@ -19,7 +20,8 @@ var SaveMdRpc = Rpc.define({
         no_markdown_text: NoDetails,
         invalid_path: InvalidPathDetails,
         destination_exists: DestinationDetails,
-        filesystem_write_failed: DestinationDetails
+        filesystem_write_failed: DestinationDetails,
+        session_failed: SessionFailureDetails
       }
     }
   },
@@ -38,8 +40,14 @@ var SaveMdRpcFailure = z.discriminatedUnion("type", [
     type: z.literal("filesystem_write_failed"),
     message: z.string(),
     data: DestinationDetails
+  }),
+  z.object({
+    type: z.literal("session_failed"),
+    message: z.string(),
+    data: SessionFailureDetails
   })
 ]);
+var RpcFailure = z.object({ type: z.string(), message: z.string() });
 
 // src/tui.tsx
 import { Plugin } from "@opencode-ai/plugin/tui";
@@ -50,12 +58,14 @@ var tui_default = Plugin.define({
   setup(context) {
     const rpc = context.client.rpc(SaveMdRpc);
     const workflows = Semaphore.makeUnsafe(1);
+    const lifecycle = new AbortController;
     function showFailure(error) {
       const parsed = SaveMdRpcFailure.safeParse(error);
       if (!parsed.success) {
+        const fallback = RpcFailure.safeParse(error);
         context.ui.toast.show({
           title: TITLE,
-          message: error instanceof Error ? error.message : String(error),
+          message: fallback.success ? fallback.data.message : error instanceof Error ? error.message : String(error),
           variant: "error"
         });
         return;
@@ -106,7 +116,7 @@ var tui_default = Plugin.define({
           name
         }, {
           location,
-          signal
+          signal: AbortSignal.any([signal, lifecycle.signal])
         }),
         catch: (error) => error
       });
@@ -126,7 +136,7 @@ var tui_default = Plugin.define({
           variant: "warning"
         }));
       }), Effect.catchCause((cause) => {
-        if (Cause.hasInterruptsOnly(cause))
+        if (lifecycle.signal.aborted || Cause.hasInterruptsOnly(cause))
           return Effect.void;
         return Effect.sync(() => showFailure(Cause.squash(cause)));
       })));
@@ -152,10 +162,14 @@ var tui_default = Plugin.define({
       }));
       return [];
     }
-    return context.ui.slot({
+    const removeSlot = context.ui.slot({
       append: "app",
       render: AppExtensions
     });
+    return () => {
+      lifecycle.abort();
+      removeSlot();
+    };
   }
 });
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azatakmyradov/opencode-save-md-plugin",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Save the latest OpenCode assistant response as Markdown",
   "keywords": [
     "markdown",
@@ -22,15 +22,24 @@
   ],
   "type": "module",
   "exports": {
-    ".": "./dist/index.js",
-    "./tui": "./dist/tui.js",
-    "./rpc": "./dist/rpc.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./tui": {
+      "types": "./dist/tui.d.ts",
+      "import": "./dist/tui.js"
+    },
+    "./rpc": {
+      "types": "./dist/rpc.d.ts",
+      "import": "./dist/rpc.js"
+    }
   },
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "bun ../../scripts/build.ts .",
+    "build": "bun ../../scripts/build.ts . && tsc -p tsconfig.build.json",
     "check": "tsc --noEmit",
     "prepack": "bun run build",
     "test": "vp test run"