Plugin System

[wlatic]

Have been playing around with trying to get a few of the different docker management systems to try and help me enforce a very opinionated setup:

• Source of truth is local and sync'ed to get
• Binds should be done on a ZFS partition
• ZFS should have snapshots

Arcane seemed way easier to implement plugins (based on using antigravity) and I got this done using a docker compose patch file. I've then got a sidecar docker running to allow me to enable a "Ops mode" which brings in Git Sync's and some reports etc.

I'm still trying to test this locally, is plugins and addons something in Arcanes native future?

[kmendell]

I want to add some sort of system. But theres still alot of native functionality that id like to just have native in arcane. Git stuff is coming in the next update, but curious to see how you did it/

[wlatic]

This is heavily done with Antigravity:

https://github.com/wlatic/arcane-plugin

and plugin.dockerfile:

root@docker:/opt/containers/arcane# cat plugin.Dockerfile 
# Stage 0: Git Fetcher (Downloads everything once)
FROM alpine/git:latest AS git-fetcher
WORKDIR /tmp

# Clone Official Repo (Base Layer)
RUN git clone https://github.com/getarcaneapp/arcane.git arcane-base

# Clone Overrides (Patches)
RUN git clone https://github.com/wlatic/arcane-plugin.git arcane-overrides

# Stage 1: Build Frontend
FROM node:22-alpine AS frontend-builder
WORKDIR /app/frontend

# Copy package info from fetcher
COPY --from=git-fetcher /tmp/arcane-base/frontend/package.json ./package.json.base
# ... (intermediate lines skipped/handled by context) ...

# 1. Copy Base
COPY --from=git-fetcher /tmp/arcane-base/frontend ./
# 2. Copy Overrides
COPY --from=git-fetcher /tmp/arcane-overrides/frontend ./

# 3. Install & Build
RUN npm install
# Patch: Install missing dependency discovered during build
RUN npm install svelte-motion
RUN npm run build

# Stage 2: Build Backend
FROM golang:1.25-alpine AS backend-builder
WORKDIR /app/backend

# Linux build settings
ENV CGO_ENABLED=1
ENV GOOS=linux
ENV GOARCH=amd64

# Install build tools for CGO
RUN apk add --no-cache build-base

# 1. Setup Types Module (for replace directive)
# Note: Trailing slash ensures it's treated as a directory
COPY --from=git-fetcher /tmp/arcane-base/types /app/types/
# Overlay Types Overrides (if any)
COPY --from=git-fetcher /tmp/arcane-overrides/types /app/types/

# Debug: Check if types/go.mod exists
RUN ls -la /app/types/

# 2. Copy Base Source
COPY --from=git-fetcher /tmp/arcane-base/backend ./
# 2. Copy Overrides Source
COPY --from=git-fetcher /tmp/arcane-overrides/backend ./

# 3. Copy Built Frontend Assets (Required for Embedding)
# Svelte config outputs to ../backend/frontend/dist, so in frontend-builder it is at /app/backend/frontend/dist
COPY --from=frontend-builder /app/backend/frontend/dist ./frontend/dist

# 4. Download Deps & Build
# Debug: Check that we can see the module
RUN cat ./go.mod | grep replace || echo "No replace found"
RUN go mod download
RUN go build -ldflags="-w -s" -o arcane-linux cmd/main.go

# Stage 3: Final Runtime Image
FROM alpine:latest
WORKDIR /app

# Install runtime libs
RUN apk add --no-cache ca-certificates tzdata sqlite

# Copy Backend Binary
COPY --from=backend-builder /app/backend/arcane-linux /app/arcane
RUN chmod +x /app/arcane

# Migrations
COPY --from=backend-builder /app/backend/resources/migrations /app/resources/migrations

# Expose
EXPOSE 8080

CMD ["/app/arcane"]

The Ops plugin I created:

https://github.com/wlatic/arcane-ops-plugin

Ran via another docker:

Compose.yaml:
plugin-ops:
build:
context: .
dockerfile: ops.Dockerfile
image: arcane-plugin-ops:latest
container_name: arcane-plugin-ops
ports:
- '3553:8081'
environment:
- PORT=8081
- DB_PATH=/app/data/arcane.db
volumes:
- /var/run/docker.sock:/var/run/docker.sock
# IMPORTANT: Map the SAME volume as your main arcane service
- ./arcane-data:/app/data
- /opt/containers:/opt/containers
restart: unless-stopped

ops.dockerfile

# Build Stage
FROM golang:1.25-alpine AS builder

WORKDIR /app

# Install git and build tools (for CGO)
RUN apk add --no-cache git build-base

WORKDIR /app

# Clone Plugin Repo
RUN git clone https://github.com/wlatic/arcane-ops-plugin.git .

RUN go mod download

# Build
RUN CGO_ENABLED=1 GOOS=linux go build -o plugin-server main.go

# Runtime Stage
FROM alpine:latest

WORKDIR /app

# Install runtime dependencies (git, zfs tooling if possible/simulated, docker-cli if needed)
# Note: Installing actual ZFS kernel modules in Alpine container isn't possible, users usually map /dev/zfs or use a privileged container.
# For Docker CLI, we also install it to allow the plugin to talk to the host socket.
RUN apk add --no-cache git docker-cli

COPY --from=builder /app/plugin-server .

EXPOSE 8081

CMD ["./plugin-server"]

Registered the plugin via CLI:

curl -X POST http://localhost:3552/api/environments/local/plugins/register   -H "Authorization: Bearer <YOUR_API_TOKEN>"   -d '{
    "plugin_id": "resilience_ops",
    "base_url": "http://arcane-plugin-ops:8081"
  }'

Its definately a brute force method, I just have a pretty opinionated way I do docker to make sure its backed up etc.

[kmendell]

@wlatic Im interested in your approach here i think its can be simplified for sure... but do you mind opening a PR with thats logic and we can work to improve it?

[kmendell]

This is interesting, I will look and see if we can streamline it and make it more intunitive, if you want to make a simple pr with some ideas too feel free, but this is something ive had an idea for for a long time just wanst sure how to do it ...

[wlatic]

The one thing that stops me from submitting a PR here is that I think the majority of time I like things to be less simple and deliberate because people should know what they are doing. But within software that is really a no no.

My thoughts are also with the amount of AI development going on now it might need to be a "simple plugin" system, but the ability for more complicated integrations being done via Antigravity/Claude Code etc.

[kmendell]

I actually added a 'buildables' functionality that does what you did kind of. Planning on extending tat in the furtue as well :)

[wlatic]

@kmendell do you have docs on this now? I'd like to try and rewrite my original plugin.

[kmendell]

@wlatic https://getarcane.app/docs/guides/buildables Is what i have not the best but at leats gives the idea

[kinghat]

would this allow the management of zfs, vms, lxc? truenas might be going nuclear on the community. ive realized that what i really wanted was something like arcane that handles zfs, since datasets couple well with volumes, and less something like truenas that handles containers. i could open a separate discussion if this isnt the correct spot.

[kmendell]

The perk of this would be anyboyd can really build/addon to it, that being said in the current state, it would require a new image with the built code, in the future maybe i can look into a regsitry for that of some sort but thats down the line.