FROM node:24-alpine3.22

# `apk add go` is not yet good, it installs `go version go1.24.13 linux/arm64` at this time of writing, but need higher version to make Docker MCP Toolkit work with `make` 
# go.mod requires go >= 1.25.5
RUN apk add --update --no-cache curl wget python3 docker docker-compose make bash git

# Copy the script to get the latest golang amd64
COPY build/get-latest-golang-amd64.sh /tmp/get-latest-golang-amd64.sh
RUN chmod +x /tmp/get-latest-golang-amd64.sh
RUN /tmp/get-latest-golang-amd64.sh
RUN rm /tmp/get-latest-golang-amd64.sh
ENV PATH="$PATH:/usr/local/go/bin"
RUN go version

# Copy the script to build the docker mcp toolkit
COPY build/build-docker-mcp-toolkit.sh /tmp/build-docker-mcp-toolkit.sh
RUN chmod +x /tmp/build-docker-mcp-toolkit.sh
RUN /tmp/build-docker-mcp-toolkit.sh
RUN rm /tmp/build-docker-mcp-toolkit.sh

# Install `uv`
RUN curl -LsSf https://astral.sh/uv/install.sh | sh
ENV PATH="/root/.local/bin:$PATH"

# Copy `mcpo` config
COPY data/config.json /data/config.json

CMD ["uvx", "mcpo", "--port", "8000", "--config", "/data/config.json"]

services:
  mcpo:
    build: .
    restart: unless-stopped
    # ports:
    #   - "8000:8000"
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock  # REQUIRED: For docker mcp inside mcpo
      - /root/.docker/mcp:/root/.docker/mcp:ro  # REQUIRED: Toolkit profiles/servers

networks:
  cloudflared:
    external: true

services:
  mcpo:
    networks:
      - cloudflared

#!/bin/sh
ORIGIN_URL="https://go.dev"
LATEST_URL=$(wget -qO- https://go.dev/dl/ | grep -oE 'href="[^"]*linux-amd64\.tar\.gz"' | cut -d'"' -f2 | head -1)
wget -O /tmp/go.tar.gz "$ORIGIN_URL/$LATEST_URL"
rm -rf /usr/local/go
tar -C /usr/local -xzf /tmp/go.tar.gz
rm /tmp/go.tar.gz
export PATH=$PATH:/usr/local/go/bin
echo 'export PATH=$PATH:/usr/local/go/bin' >> ~/.profile
go version

#!/bin/sh
# Clone the repository
cd /tmp
git clone --depth 1 https://github.com/docker/mcp-gateway.git
cd mcp-gateway
mkdir -p "$HOME/.docker/cli-plugins/"
# Build and install the plugin
make docker-mcp

docker mcp --help
rm -rf /tmp/mcp-gateway

docker run --rm -v ~/source:/source -v /Volume/destination/HD:/destination -it alpine sh

apk add rsync

rsync -vaP /source /destination

FROM alpine:latest as BUILDER

RUN apk add --no-cache go git

WORKDIR /data

RUN git clone --depth 1 https://github.com/acme-dns/acme-dns-client && \
    cd acme-dns-client && \
    go get && \
    go build

FROM alpine:latest
RUN apk add --no-cache certbot

# Copy the built binary from the BUILDER stage
COPY --from=BUILDER /data/acme-dns-client/acme-dns-client /usr/local/bin/acme-dns-client

CMD ["/usr/local/bin/acme-dns-client"]

#!/bin/bash
docker build -t harianto/acmedns-client -f build/Dockerfile build

#!/bin/bash
mkdir -p data/letsencrypt
docker run --rm -v ${pwd}/data/letsencrypt:/etc/letsencrypt -it harianto/acmedns-client sh

#!/bin/bash
mkdir -p data/letsencrypt
docker run --rm \
-v ${pwd}/data/letsencrypt:/etc/letsencrypt \
-it harianto/acmedns-client certbot \
  certonly \
  --manual \
  --preferred-challenges dns \
  --server https://acme-staging-v02.api.letsencrypt.org/directory \
  --agree-tos \
  -m letsencrypt@newdomain.com \
  --no-eff-email \
  --manual-auth-hook '/usr/local/bin/acme-dns-client' \
  "$@"

#!/bin/bash
docker run --rm \
-v ${pwd}/data/letsencrypt:/etc/letsencrypt \
-it harianto/acmedns-client acme-dns-client "$@"

./certbot.sh -d newdomain.com -d *.newdomain.com

# create directory
mkdir -p /docker/acmedns
# goto
cd /docker/acmedns
# git clone: depth 1
git clone --depth 1 https://github.com/acme-dns/acme-dns.git build
# create empty file and chmod +x
touch docker-build.sh; chmod +x docker-build.sh

#!/bin/bash
docker build -t harianto/acmedns-server -f build/Dockerfile build

FROM golang:alpine AS builder
LABEL maintainer="joona@kuori.org"

RUN apk add --update gcc musl-dev git

ENV GOPATH /tmp/buildcache
RUN git clone https://github.com/joohoi/acme-dns /tmp/acme-dns
WORKDIR /tmp/acme-dns
RUN CGO_ENABLED=1 CGO_CFLAGS="-D_LARGEFILE64_SOURCE" go build

FROM alpine:latest

WORKDIR /root/
COPY --from=builder /tmp/acme-dns .
RUN mkdir -p /etc/acme-dns
RUN mkdir -p /var/lib/acme-dns
RUN rm -rf ./config.cfg
RUN apk --no-cache add ca-certificates && update-ca-certificates

VOLUME ["/etc/acme-dns", "/var/lib/acme-dns"]
ENTRYPOINT ["./acme-dns"]
EXPOSE 53 80 443
EXPOSE 53/udp

# goto dir
cd /docker/acmedns
# build it
./docker-build.sh

# create volume: docker volume create --name=letsencrypt
#volumes:
#  letsencrypt:
#    external: true

services:
  acmedns:
    image: harianto/acmedns-server
    container_name: acmedns
    #network_mode: host
    ports:
      - "53:53"
      - "53:53/udp"
      - "80:80"
      - "443:443"
    volumes:
      - ./data/acmedns_config:/etc/acme-dns:ro
      - ./data/acmedns_acmd-dns:/var/lib/acme-dns
      #- letsencrypt:/etc/letsencrypt:ro
    restart: unless-stopped  # Optional: to ensure the container restarts on failure

[general]
# DNS interface. Note that systemd-resolved may reserve port 53 on 127.0.0.53
# In this case acme-dns will error out and you will need to define the listening interface
# for example: listen = "127.0.0.1:53"
listen = "0.0.0.0:53"
# protocol, "both", "both4", "both6", "udp", "udp4", "udp6" or "tcp", "tcp4", "tcp6"
protocol = "both"
# domain name to serve the requests off of
domain = "auth.myacmedns.com"
# zone name server
nsname = "auth.myacmedns.com"
# admin email address, where @ is substituted with .
nsadmin = "admin.myacmedns.com"
# predefined records served in addition to the TXT
records = [
    # domain pointing to the public IP of your acme-dns server 
    "auth.myacmedns.com. A 31.14.98.159",
    # specify that auth.myacmedns.com will resolve any *.auth.myacmedns.com records
    "auth.myacmedns.com. NS auth.myacmedns.com.",
]
# debug messages from CORS etc
debug = false

[database]
# Database engine to use, sqlite3 or postgres
engine = "sqlite3"
# Connection string, filename for sqlite3 and postgres://$username:$password@$host/$db_name for postgres
# Please note that the default Docker image uses path /var/lib/acme-dns/acme-dns.db for sqlite3
connection = "/var/lib/acme-dns/acme-dns.db"
# connection = "postgres://user:password@localhost/acmedns_db"

[api]
# listen ip eg. 127.0.0.1
ip = "0.0.0.0"
# disable registration endpoint
disable_registration = false
# listen port, eg. 443 for default HTTPS
port = "443"
# possible values: "letsencrypt", "letsencryptstaging", "cert", "none"
tls = "cert"
# only used if tls = "cert"
tls_cert_privkey = "/etc/letsencrypt/live/myacmedns.com/privkey.pem"
tls_cert_fullchain = "/etc/letsencrypt/live/myacmedns.com/fullchain.pem"
# only used if tls = "letsencrypt"
acme_cache_dir = "api-certs"
# optional e-mail address to which Let's Encrypt will send expiration notices for the API's cert
notification_email = ""
# CORS AllowOrigins, wildcards can be used
corsorigins = [
    "*"
]
# use HTTP header to get the client ip
use_header = false
# header name to pull the ip address / list of ip addresses from
header_name = "X-Forwarded-For"

[logconfig]
# logging level: "error", "warning", "info" or "debug"
loglevel = "debug"
# possible values: stdout, TODO file & integrations
logtype = "stdout"
# file path for logfile TODO
# logfile = "./acme-dns.log"
# format, either "json" or "text"
logformat = "text"

# goto
cd /docker/acmedns-client
# register once
./acmedns-client.sh register -s https://auth.myacmedns.com

# create volume: docker volume create --name=letsencrypt
volumes:
  letsencrypt:
    external: true

services:
  nginx:
    image: nginx:alpine
    restart: always
    links:
      - 8-0-0-fpm-ext
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./data/nginx/enabled:/etc/nginx/conf.d
      - ./data/nginx/snippets:/nginx/snippets
      - ./data/nginx/certificates:/nginx/certificates
      - letsencrypt:/etc/letsencrypt:ro
    volumes_from:
      - data

  8-0-0-fpm-ext:
    build: build/8-0-0-fpm-ext
    restart: always
    volumes_from:
      - data

  db:
    image: mariadb:10.5.8 #v10.5.8
    restart: always
    environment:
      MYSQL_ROOT_PASSWORD: root
    volumes:
      - ./data/db:/var/lib/mysql

  dbadmin:
    image: phpmyadmin/phpmyadmin
    restart: always
    environment:
      PMA_HOST: db
      PMA_USER: root # Remove line for production
      PMA_PASSWORD: root # Remove line for production
    depends_on:
      - db

  data:
    image: alpine:latest
    command: echo "--- Docker data volume READY."
    volumes:
      - ./data/vhosts:/vhosts
      - ./data/tmp:/tmp

# create network: docker network create xnmp-network
networks:
  default:
    name: xnmp-network
    external: true

# create volume: docker volume create --name=letsencrypt
volumes:
  letsencrypt:
    external: true

services:
  mailserver:
    image: analogic/poste.io:latest
    hostname: mail.harianto.dev
    environment:
      - TZ=Europe/Amsterdam
      - MODE=pro
    volumes:
      - ./data/mailserver:/data
      - letsencrypt:/etc/letsencrypt
    ports:
      # - 80:80/tcp   # HTTP
      # - 443:443/tcp # HTTPS
      - 25:25/tcp   # SMTP
      - 465:465/tcp # SMTPS
      - 587:587/tcp # SMTP
      - 110:110/tcp # POP3
      - 995:995/tcp # POP3S
      - 143:143/tcp # IMAP
      - 993:993/tcp # IMAPS
      - 4190:4190/tcp # Sieve
    # network_mode: host

# create network: docker network create xnmp-network
networks:
  default:
    name: xnmp-network
    external: true

# add user `mail` to `root` group
sudo adduser mail root

# make a symlink from a mounted letsencrypt
cd /data/ssl
rm -rf letsencrypt
ln -nsf /etc/letsencrypt/live /data/ssl/letsencrypt

# exit docker terminal
exit

npm i @harianto/axioscancelable

npm create vite-extra@latest my-vite-vue-ssr -- --template ssr-vue

Scaffolding project in /Users/harianto/Projects/my-vite-vue-ssr...

Done. Now run:

  cd my-vite-vue-ssr
  npm install
  npm run dev

node -v > .nvmrc

# Created by .ignore support plugin (hsz.mobi)
### Node template
# Logs
/logs
*.log
npm-debug.log*
yarn-debug.log*
yarn-error.log*

# Runtime data
pids
*.pid
*.seed
*.pid.lock

# Directory for instrumented libs generated by jscoverage/JSCover
lib-cov

# Coverage directory used by tools like istanbul
coverage

# nyc test coverage
.nyc_output

# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
.grunt

# Bower dependency directory (https://bower.io/)
bower_components

# node-waf configuration
.lock-wscript

# Compiled binary addons (https://nodejs.org/api/addons.html)
build/Release

# Dependency directories
node_modules/
jspm_packages/

# TypeScript v1 declaration files
typings/

# Optional npm cache directory
.npm

# Optional eslint cache
.eslintcache

# Optional REPL history
.node_repl_history

# Output of 'npm pack'
*.tgz

# Yarn Integrity file
.yarn-integrity

# dotenv environment variables file
.env

# parcel-bundler cache (https://parceljs.org/)
.cache

# next.js build output
.next

# nuxt.js build output
# .nuxt

# Nuxt generate
dist

# vuepress build output
.vuepress/dist

# Serverless directories
.serverless

# IDE / Editor
.idea

# Service worker
sw.*

# Mac OSX
.DS_Store

# Vim swap files
*.swp

# VSCode Settings
.vscode

# APP IGNORES
package-lock.json
.git
.docker-mount

  "scripts": {
    "docker": "cross-env NODE_ENV=production npm run dev",
    "docker:build": "npm run build && docker build -t dockeruser/my-vite-vue-ssr .",
    "docker:run": "docker run --rm -p 3000:3000 dockeruser/my-vite-vue-ssr",
    "docker:push": "npm run docker:build && docker push dockeruser/my-vite-vue-ssr"
  },

{
  "name": "my-vite-vue-ssr",
  "private": true,
  "version": "0.0.0",
  "type": "module",
  "scripts": {
    "dev": "node server",
    "build": "npm run build:client && npm run build:server",
    "build:client": "vite build --ssrManifest --outDir dist/client",
    "build:server": "vite build --ssr src/entry-server.js --outDir dist/server",
    "preview": "cross-env NODE_ENV=production node server",
    "docker": "cross-env NODE_ENV=production npm run dev",
    "docker:build": "npm run build && docker build -t dockeruser/my-vite-vue-ssr .",
    "docker:run": "docker run --rm -p 3000:3000 dockeruser/my-vite-vue-ssr",
    "docker:push": "npm run docker:build && docker push dockeruser/my-vite-vue-ssr"
  },
  "dependencies": {
    "compression": "^1.7.4",
    "express": "^4.18.2",
    "sirv": "^2.0.4",
    "vue": "^3.3.13",
    "@vitejs/plugin-vue": "^4.5.2",
    "cross-env": "^7.0.3",
    "vite": "^5.0.10"
  },
  "devDependencies": {}
}

FROM node:21.6.2-alpine

EXPOSE 3000

ENV NODE_ENV=production
ENV PORT=3000
ENV NODE_WORKDIR=/app
WORKDIR $NODE_WORKDIR

COPY package.json $NODE_WORKDIR/
RUN npm shrinkwrap
RUN npm i
COPY . $NODE_WORKDIR
RUN npm run build

CMD ["npm", "run", "docker"]

npm run docker:build

7d32fd2396d8   dockeruser/my-vite-vue-ssr           "docker-entrypoint.s…"   13 minutes ago   Up 13 minutes   0.0.0.0:3000->3000/tcp                     stupefied_cohen

docker rm -f 7d32fd2396d8

// Factory: createEventBus
const createEventBus = function () {
  const state = {
    listeners: {}
  }

  const methods = {
    // addEventListener
    $on(eventType, callback) {
      if (!Array.isArray(state.listeners[eventType])) {
        state.listeners[eventType] = []
      }
      if (state.listeners[eventType].indexOf(callback) === -1)
        state.listeners[eventType].push(callback)
    },
    // removeEventListener
    $off(eventType, callback) {
      if (Array.isArray(state.listeners[eventType])) {
        const index = state.listeners[eventType].indexOf(callback)
        if (index !== -1) state.listeners[eventType].splice(index, 1)
      }
    },
    // dispatchEvent
    $emit(eventType, data) {
      if (Array.isArray(state.listeners[eventType]))
        state.listeners[eventType].forEach(cb => cb(data))
    },
    // reset listeners
    $destroy() {
      state.listeners = {}
    }
  }

  return methods
}

// Class: EventBus
const EventBus = function () {
  Object.assign(this, createEventBus())
}

export default createEventBus
export { EventBus }

import createEventBus from './createEventBus'

// create the product (from Factory)
const eventBus = createEventBus()
export default eventBus

import { EventBus } from './createEventBus'

// instantiate EventBus
const eventBus = new EventBus()
export default eventBus

<script>
import createEventBus from './createEventBus'

export default {
  // LifeCycle Hooks
  beforeCreate() {
    // create the product (from Factory)
    const eventBus = eventEventBus()
    const {
      $on: $$on,
      $off: $$off,
      $emit: $$emit // Vue has internal $emit, change to $$emit
    } = eventBus
    // assign to Proxy Object
    Object.assign(
      this,
      { eventBus },
      {
        $$on,
        $$off,
        $$emit
      }
    )
  },
  mounted() {
    this.intervalID = setInterval(() => {
      this.$$emit('tick', 'Tick Tock')
    }, 1e3)
  },
  beforeUnmount() {
    // destroy IntervalID 
    clearInterval(this.intervalID)
    // destroyes all eventBus event listeners
    this.eventBus.$destroy()   
  }
}
</script>

import Vue from 'vue'
import Types from './Types.vue'

const methods = {
  extendedTypes({ type, title, message }) {
    const ExtendedVue = Vue.extend(Types)
    const vm = new ExtendedVue({
      propsData: {
        type,
        title,
        message,
      },
    }).$mount()
    return vm
  }
}

// vm (aka Proxy Object)
const proxy = methods.extendedTyes('default', 'Hello', 'World')
const node = proxy.$el

import { createApp } from 'vue'
import Types from './Types.vue'

const extend = (
  vueOjbject = { template: `<span>test</span>` },
  props = {}
) => {
  const template = document.createElement('template')
  const app = createApp(vueOjbject, props)
  return app.mount(template) // Proxy Object
}

const methods = {
  extendedTypes({ type, title, message }) {
    return extend(Types, { type, title, message })
  }
}

// vm (aka Proxy Object)
const proxy = methods.extendedTyes('default', 'Hello', 'World')
const node = proxy.$el

const appendChild = (parentNode, childNode) => {
  console.log(`-------# constructor: ${childNode?.constructor?.name}`)
 
  switch (true) {
    case childNode instanceof HTMLTemplateElement:
      console.log('---- HTMLTemplateElement')
      Array.from(childNode.childNodes).forEach(child =>
        parentNode.appendChild(child)
      )
      break

    case childNode instanceof Text:
      console.log('---- Text: Proxy.$el')
      appendChild(parentNode, childNode.parentNode)
      break

    case childNode instanceof HTMLElement:
      console.log('---- HTMLElement')
      parentNode.appendChild(childNode)
      break

    default:
      console.log('---- nothing')
      break
  }
}

import { defineComponent, createApp, reactive } from 'vue/dist/vue.esm-bundler'

const template = document.createElement('template')
const component = defineComponent({
  template: `<h1 v-text="title"/>
    <p v-text="description" />
    <button @click="onClick">{{ buttonName }}</button>`,
  props: ['title']},
  data: () => ({
    buttonName: 'Click,
    description: ''
  }),
  methods: {
    onClick() {
      // Use `proxy` aka `vm`
      if (typeof this.clicked === 'function') this.clicked(this)
    }
  }
)
const app = createApp(component, { title: 'Master of Code' })

// kind of `vm` instance after `mount`
const proxy = app.mount(template)

// controll the Vue Module
// --- attach `clicked` function
proxy.clicked = vm => {
  vm.buttonName = 'Clicked'
  alert('Button is clicked')
}


// appendChild to a element `parentNode`
const vInjectElements = () => {
  const log = console.log
  let logText = '/root'
  const appendChild = (parentNode, childNode) => {
    log(`-- # constructor: ${childNode?.constructor?.name}`)
    logText += '.constructor'
    let template
    switch (true) {
      case childNode instanceof HTMLTemplateElement:
        log('---- HTMLTemplateElement')
        logText += '.HTMLTemplateElement'
        log(logText)
        Array.from(childNode.childNodes).forEach(child =>
          parentNode.appendChild(child)
        )
        break

      case childNode instanceof Text:
        log('---- Text: Proxy.$el')
        logText += '.Text'
        // template Element from childNode.parentNode
        appendChild(parentNode, childNode.parentNode)
        break

      case childNode instanceof DocumentFragment:
        log('---- DocumentFragment')
        logText += '.DocumentFragment'
        log(logText)
        parentNode.appendChild(childNode)
        break

      case childNode instanceof HTMLElement:
        log('---- HTMLElement')
        logText += '.HTMLElement'
        log(logText)
        parentNode.appendChild(childNode)
        break

      case childNode instanceof Object:
        log('---- Object Vue Component')
        template = document.createElement('template')
        logText += '.VueComponent'
        // Check if object is a Vue App or Vue Component
        if (typeof childNode.mount === 'function') {
          // Vue App
          log('------ by: createApp')
          logText += '.createApp'
          if (childNode._container) {
            log('-------- is already mounted')
            logText += '._container'
            template = childNode._container
          } else {
            log('-------- mount the childNode')
            logText += '.mountChildNodeToTemplate'
            childNode.mount(template)
          }
        } else {
          // Vue Component
          log('------ by: defineComponent')
          logText += '.defineComponent'
          if (childNode?.$?.isMounted) {
            logText += '.$el'
            template = childNode.$el
          } else {
            logText += '.createAppAndMount'
            createApp(childNode).mount(template)
          }
        }
        appendChild(parentNode, template)
        break

      default:
        log('---- nothing')
        logText += '.nothing'
        log(logText)
        break
    }
  }
  
  return {
    mounted(el, binding) {
      const { value: elements } = binding
      elements.forEach(childNode => appendChild(el, childNode))
    }
  }
}

export default {
  directives: {
    injectElements: vInjectElements
  },
  data: () => ({
    list: []
  }),
  template: `<h1>Title</h1>
  <p>Some paragraph here</p>
  <section v-inject-elements="list" />`
}