@azatakmyradov/opencode-save-md-plugin 0.0.0

package/README.md

@@ -0,0 +1,54 @@
+# OpenCode save Markdown plugin
+
+Save the latest assistant response from an OpenCode V2 session as a Markdown file in the server workspace.
+
+## Install
+
+```bash
+opencode2 plugin add @azatakmyradov/opencode-save-md-plugin
+opencode2 service restart
+```
+
+The package exposes server, TUI, and portable RPC entrypoints. OpenCode V2 loads the TUI entrypoint automatically when the package is installed.
+
+## Use
+
+```text
+/save-md design
+/save-md notes/design.md
+```
+
+The first command writes `design.md`; the second keeps the supplied `.md` suffix. The command waits for an active response to finish, then saves only the latest assistant message from the active context. Text parts are preserved and joined with a blank line; reasoning and tool parts are excluded.
+
+Writes happen in the server process, so a remote TUI saves into the server workspace. Absolute paths and relative paths that escape the current location are rejected. Existing files are never overwritten.
+
+## Local Development
+
+Install the workspace and verify the package:
+
+```bash
+bun install
+bun run --filter @azatakmyradov/opencode-save-md-plugin check
+bun run --filter @azatakmyradov/opencode-save-md-plugin test
+bun run --filter @azatakmyradov/opencode-save-md-plugin build
+```
+
+Load the package directory by absolute path in a project `opencode.jsonc`:
+
+```jsonc
+{
+  "$schema": "https://opencode.ai/config.json",
+  "plugins": ["/absolute/path/to/opencode-plugins/packages/save-md"],
+}
+```
+
+The package's root development entrypoints load `src/index.ts` and `src/tui.tsx`, so the server and matching TUI plugin are both discovered. Run the package build first only when testing the npm `dist` exports.
+
+## Publish
+
+Create a changeset for normal releases. To bootstrap npm trusted publishing for this package:
+
+```bash
+npm publish --workspace @azatakmyradov/opencode-save-md-plugin
+npm trust github @azatakmyradov/opencode-save-md-plugin --file release.yml --repo azatakmyradov/opencode-plugins --allow-publish
+```

package/dist/index.js

@@ -0,0 +1,188 @@
+// @bun
+// src/rpc.ts
+import { Rpc } from "@opencode-ai/plugin/rpc";
+import { z } from "zod";
+var NoDetails = z.object({});
+var InvalidPathDetails = z.object({ name: z.string() });
+var DestinationDetails = z.object({ path: z.string() });
+var SaveMdRpc = Rpc.define({
+  id: "save-md",
+  methods: {
+    save: {
+      input: z.object({
+        sessionID: z.string().min(1),
+        name: z.string().min(1)
+      }),
+      output: z.object({ path: z.string() }),
+      errors: {
+        no_assistant_response: NoDetails,
+        no_markdown_text: NoDetails,
+        invalid_path: InvalidPathDetails,
+        destination_exists: DestinationDetails,
+        filesystem_write_failed: DestinationDetails
+      }
+    }
+  },
+  events: {}
+});
+var SaveMdRpcFailure = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("no_assistant_response"), message: z.string(), data: NoDetails }),
+  z.object({ type: z.literal("no_markdown_text"), message: z.string(), data: NoDetails }),
+  z.object({ type: z.literal("invalid_path"), message: z.string(), data: InvalidPathDetails }),
+  z.object({
+    type: z.literal("destination_exists"),
+    message: z.string(),
+    data: DestinationDetails
+  }),
+  z.object({
+    type: z.literal("filesystem_write_failed"),
+    message: z.string(),
+    data: DestinationDetails
+  })
+]);
+
+// src/index.ts
+import { Effect as Effect2 } 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 { DateTime, Effect, Schema } from "effect";
+
+class NoAssistantResponseError extends Schema.TaggedError()("NoAssistantResponseError", { message: Schema.String }) {
+}
+
+class NoMarkdownTextError extends Schema.TaggedError()("NoMarkdownTextError", { message: Schema.String }) {
+}
+
+class InvalidPathError extends Schema.TaggedError()("InvalidPathError", {
+  name: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class DestinationExistsError extends Schema.TaggedError()("DestinationExistsError", {
+  path: Schema.String,
+  message: Schema.String
+}) {
+}
+
+class FileSystemWriteError extends Schema.TaggedError()("FileSystemWriteError", {
+  path: Schema.String,
+  message: Schema.String,
+  cause: Schema.Defect()
+}) {
+}
+var ExistingFileSystemError = Schema.Struct({ code: Schema.Literal("EEXIST") });
+var isExistingFileSystemError = Schema.is(ExistingFileSystemError);
+var selectLatestAssistant = Effect.fn("selectLatestAssistant")(function* (messages) {
+  let latest;
+  for (const message of messages) {
+    if (message.type !== "assistant")
+      continue;
+    if (!latest || DateTime.toEpochMillis(message.time.created) >= DateTime.toEpochMillis(latest.time.created)) {
+      latest = message;
+    }
+  }
+  if (!latest) {
+    return yield* new NoAssistantResponseError({
+      message: "No assistant response is available in the active session context."
+    });
+  }
+  return latest;
+});
+var extractMarkdown = Effect.fn("extractMarkdown")(function* (message) {
+  const markdown = message.content.flatMap((part) => part.type === "text" ? [part.text] : []).join(`
+
+`);
+  if (!markdown.trim()) {
+    return yield* new NoMarkdownTextError({
+      message: "The latest assistant response contains no Markdown text."
+    });
+  }
+  return markdown;
+});
+var extractLatestMarkdown = Effect.fn("extractLatestMarkdown")(function* (messages) {
+  const assistant = yield* selectLatestAssistant(messages);
+  return yield* extractMarkdown(assistant);
+});
+var resolveMarkdownPath = Effect.fn("resolveMarkdownPath")(function* (directory, name) {
+  const requested = name.trim();
+  const invalid = requested.length === 0 || requested.includes("\x00") || isAbsolute(requested) || win32.isAbsolute(requested);
+  if (invalid) {
+    return yield* new InvalidPathError({
+      name,
+      message: "The destination must be a non-empty relative path inside the current location."
+    });
+  }
+  const root = resolve(directory);
+  const filename = requested.endsWith(".md") ? requested : `${requested}.md`;
+  const destination = resolve(root, filename);
+  const contained = relative(root, destination);
+  if (contained.length === 0 || contained === ".." || contained.startsWith(`..${sep}`) || isAbsolute(contained)) {
+    return yield* new InvalidPathError({
+      name,
+      message: "The destination path escapes the current location."
+    });
+  }
+  return destination;
+});
+var saveMarkdown = Effect.fn("saveMarkdown")(function* (directory, name, markdown) {
+  const destination = yield* resolveMarkdownPath(directory, name);
+  const content = markdown.endsWith(`
+`) ? markdown : `${markdown}
+`;
+  yield* Effect.tryPromise({
+    try: (signal) => writeFile(destination, content, {
+      encoding: "utf8",
+      flag: "wx",
+      signal
+    }),
+    catch: (cause) => {
+      if (isExistingFileSystemError(cause)) {
+        return new DestinationExistsError({
+          path: destination,
+          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 destination;
+});
+var saveLatestAssistant = Effect.fn("saveLatestAssistant")(function* (directory, name, messages) {
+  const markdown = yield* extractLatestMarkdown(messages);
+  return yield* saveMarkdown(directory, name, markdown);
+});
+
+// src/index.ts
+var src_default = Plugin.define({
+  id: "save-md",
+  effect: (ctx) => Effect2.gen(function* () {
+    yield* ctx.rpc.register(SaveMdRpc, {
+      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);
+          const path = yield* saveLatestAssistant(ctx.location.directory, name, messages);
+          return { path };
+        }).pipe(Effect2.catchTags({
+          NoAssistantResponseError: (error) => Effect2.fail(rpc.error("no_assistant_response", error.message, {})),
+          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 }))
+        }));
+      }
+    }).pipe(Effect2.orDie);
+  })
+});
+export {
+  src_default as default
+};

package/dist/rpc.js

@@ -0,0 +1,46 @@
+// @bun
+// src/rpc.ts
+import { Rpc } from "@opencode-ai/plugin/rpc";
+import { z } from "zod";
+var NoDetails = z.object({});
+var InvalidPathDetails = z.object({ name: z.string() });
+var DestinationDetails = z.object({ path: z.string() });
+var SaveMdRpc = Rpc.define({
+  id: "save-md",
+  methods: {
+    save: {
+      input: z.object({
+        sessionID: z.string().min(1),
+        name: z.string().min(1)
+      }),
+      output: z.object({ path: z.string() }),
+      errors: {
+        no_assistant_response: NoDetails,
+        no_markdown_text: NoDetails,
+        invalid_path: InvalidPathDetails,
+        destination_exists: DestinationDetails,
+        filesystem_write_failed: DestinationDetails
+      }
+    }
+  },
+  events: {}
+});
+var SaveMdRpcFailure = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("no_assistant_response"), message: z.string(), data: NoDetails }),
+  z.object({ type: z.literal("no_markdown_text"), message: z.string(), data: NoDetails }),
+  z.object({ type: z.literal("invalid_path"), message: z.string(), data: InvalidPathDetails }),
+  z.object({
+    type: z.literal("destination_exists"),
+    message: z.string(),
+    data: DestinationDetails
+  }),
+  z.object({
+    type: z.literal("filesystem_write_failed"),
+    message: z.string(),
+    data: DestinationDetails
+  })
+]);
+export {
+  SaveMdRpc,
+  SaveMdRpcFailure
+};

package/dist/tui.js

@@ -0,0 +1,163 @@
+// @bun
+// src/rpc.ts
+import { Rpc } from "@opencode-ai/plugin/rpc";
+import { z } from "zod";
+var NoDetails = z.object({});
+var InvalidPathDetails = z.object({ name: z.string() });
+var DestinationDetails = z.object({ path: z.string() });
+var SaveMdRpc = Rpc.define({
+  id: "save-md",
+  methods: {
+    save: {
+      input: z.object({
+        sessionID: z.string().min(1),
+        name: z.string().min(1)
+      }),
+      output: z.object({ path: z.string() }),
+      errors: {
+        no_assistant_response: NoDetails,
+        no_markdown_text: NoDetails,
+        invalid_path: InvalidPathDetails,
+        destination_exists: DestinationDetails,
+        filesystem_write_failed: DestinationDetails
+      }
+    }
+  },
+  events: {}
+});
+var SaveMdRpcFailure = z.discriminatedUnion("type", [
+  z.object({ type: z.literal("no_assistant_response"), message: z.string(), data: NoDetails }),
+  z.object({ type: z.literal("no_markdown_text"), message: z.string(), data: NoDetails }),
+  z.object({ type: z.literal("invalid_path"), message: z.string(), data: InvalidPathDetails }),
+  z.object({
+    type: z.literal("destination_exists"),
+    message: z.string(),
+    data: DestinationDetails
+  }),
+  z.object({
+    type: z.literal("filesystem_write_failed"),
+    message: z.string(),
+    data: DestinationDetails
+  })
+]);
+
+// src/tui.tsx
+import { Plugin } from "@opencode-ai/plugin/tui";
+import { Cause, Effect, Option, Semaphore } from "effect";
+var TITLE = "Save Markdown";
+var tui_default = Plugin.define({
+  id: "save-md",
+  setup(context) {
+    const rpc = context.client.rpc(SaveMdRpc);
+    const workflows = Semaphore.makeUnsafe(1);
+    function showFailure(error) {
+      const parsed = SaveMdRpcFailure.safeParse(error);
+      if (!parsed.success) {
+        context.ui.toast.show({
+          title: TITLE,
+          message: error instanceof Error ? error.message : String(error),
+          variant: "error"
+        });
+        return;
+      }
+      const failure = parsed.data;
+      const warning = failure.type === "no_assistant_response" || failure.type === "no_markdown_text" || failure.type === "invalid_path" || failure.type === "destination_exists";
+      context.ui.toast.show({
+        title: TITLE,
+        message: failure.message,
+        variant: warning ? "warning" : "error"
+      });
+    }
+    const runWorkflow = Effect.fn("SaveMd.runWorkflow")(function* (input) {
+      const route = yield* Effect.sync(() => context.ui.router.current());
+      if (route.type !== "session") {
+        yield* Effect.sync(() => context.ui.toast.show({
+          title: TITLE,
+          message: "Open a session before saving an assistant response.",
+          variant: "warning"
+        }));
+        return;
+      }
+      const name = input?.trim();
+      if (!name) {
+        yield* Effect.sync(() => context.ui.toast.show({
+          title: TITLE,
+          message: "Provide a destination name, for example: /save-md design",
+          variant: "warning"
+        }));
+        return;
+      }
+      const session = yield* Effect.sync(() => context.data.session.get(route.sessionID));
+      if (!session) {
+        yield* Effect.sync(() => context.ui.toast.show({
+          title: TITLE,
+          message: "The active session is not available yet.",
+          variant: "warning"
+        }));
+        return;
+      }
+      const location = {
+        directory: session.location.directory,
+        workspace: session.location.workspaceID
+      };
+      const result = yield* Effect.tryPromise({
+        try: (signal) => rpc.save({
+          sessionID: route.sessionID,
+          name
+        }, {
+          location,
+          signal
+        }),
+        catch: (error) => error
+      });
+      yield* Effect.sync(() => context.ui.toast.show({
+        title: TITLE,
+        message: `Saved ${context.ui.format.path(result.path)}`,
+        variant: "success"
+      }));
+    });
+    function run(input) {
+      return Effect.runPromise(workflows.withPermitsIfAvailable(1)(runWorkflow(input)).pipe(Effect.flatMap((result) => {
+        if (Option.isSome(result))
+          return Effect.void;
+        return Effect.sync(() => context.ui.toast.show({
+          title: TITLE,
+          message: "A save workflow is already running.",
+          variant: "warning"
+        }));
+      }), Effect.catchCause((cause) => {
+        if (Cause.hasInterruptsOnly(cause))
+          return Effect.void;
+        return Effect.sync(() => showFailure(Cause.squash(cause)));
+      })));
+    }
+    function AppExtensions() {
+      context.keymap.layer(() => ({
+        mode: "global",
+        priority: 10,
+        commands: [{
+          id: "save-md.save",
+          title: "Save assistant response as Markdown",
+          group: "Markdown",
+          description: "Save the latest assistant response in the server workspace.",
+          palette: true,
+          suggested: true,
+          bind: false,
+          slash: {
+            name: "save-md",
+            arguments: true
+          },
+          run
+        }]
+      }));
+      return [];
+    }
+    return context.ui.slot({
+      append: "app",
+      render: AppExtensions
+    });
+  }
+});
+export {
+  tui_default as default
+};

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@azatakmyradov/opencode-save-md-plugin",
+  "version": "0.0.0",
+  "description": "Save the latest OpenCode assistant response as Markdown",
+  "keywords": [
+    "markdown",
+    "opencode",
+    "opencode-plugin",
+    "tui"
+  ],
+  "homepage": "https://github.com/azatakmyradov/opencode-plugins/tree/main/packages/save-md",
+  "bugs": "https://github.com/azatakmyradov/opencode-plugins/issues",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/azatakmyradov/opencode-plugins.git",
+    "directory": "packages/save-md"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tui": "./dist/tui.js",
+    "./rpc": "./dist/rpc.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "bun ../../scripts/build.ts .",
+    "check": "tsc --noEmit",
+    "prepack": "bun run build",
+    "test": "vp test run"
+  },
+  "dependencies": {
+    "@opencode-ai/client": "0.0.0-beta-18721",
+    "@opencode-ai/plugin": "0.0.0-beta-18721",
+    "@opencode-ai/schema": "0.0.0-beta-18721",
+    "effect": "4.0.0-rc.112",
+    "zod": "4.1.8"
+  },
+  "peerDependencies": {
+    "@opentui/core": ">=0.5.9",
+    "@opentui/solid": ">=0.5.9",
+    "solid-js": ">=1.9.0"
+  },
+  "peerDependenciesMeta": {
+    "@opentui/core": {
+      "optional": true
+    },
+    "@opentui/solid": {
+      "optional": true
+    },
+    "solid-js": {
+      "optional": true
+    }
+  }
+}