西夏王朝到底有多混亂？至今都是個謎

PyMicroChat

 

声明：本项目仅用于通信方面知识的学习交流，请勿用于非法用途.

Python3.3以上的版本通过venv模块原生支持虚拟环境，可以代替Python之前的virtualenv.低版本请用pip安装。

git clone https://github.com/InfiniteTsukuyomi/PyMicroChat.git
or git clone git@github.com:InfiniteTsukuyomi/PyMicroChat.git

Windows环境

创建Python3的venv虚拟环境

D:\VSCODE\PyMicroChat>python3 -m venv .

进入虚拟环境

D:\VSCODE\PyMicroChat>.\Scripts\activate

首次执行，配置依赖包，以后根据更新依赖环境运行

(PyMicroChat) D:\VSCODE\PyMicroChat>pip install -r requirements.txt

修改run.py相应的usrname & passwd，执行

(PyMicroChat) D:\VSCODE\PyMicroChat>python run.py

退出

(PyMicroChat) D:\VSCODE\PyMicroChat>deactivate

工程中的dll文件源码地址：https://github.com/InfiniteTsukuyomi/MicroChat/tree/master/test/ecdh

from  https://github.com/LSilent/PyMicroChat

awesome-deeplearning-resources

 Deep Learning and deep reinforcement learning research papers and some codes.

A list of recent papers regarding deep learning and deep reinforcement learning. They are sorted by time to see the recent papers first. I will renew the recent papers and add notes to these papers.

You should find the papers and software with star flag are more important or popular.

Table of Contents

• Papers
• Model Zoo
• Pretrained Model
• Courses
• Books
• Tutorials
• Software
• Applications
• Awesome Projects
• Corpus

Papers

• 2021 year
  • computer vision
  • natural language process
  • multi model
• 2020 year
  • deep learning
  • deep reinforcement learning
  • natural language process
  • computer vision
• 2019 year
  • deep learning
  • deep reinforcement learning
  • natural language process
  • computer vision
• 2018 year
  • deep learning
  • deep reinforcement learning
  • natural language process
  • computer vision
• 2017 year
  • deep learning
  • deep reinforcement learning
  • natural language process
  • computer vision
• 2016 year
  • deep learning
  • deep reinforcement learning
  • natural language process
  • computer vision
• 2015 year
• 2014 year
• 2013 year
• 2012 year
• 2011 year
• 2010 year
• before 2010 year

Model Zoo

• 2012 | AlexNet: ImageNet Classification with Deep Convolutional Neural Networks. pdf code
• 2013 | RCNN: Rich feature hierarchies for accurate object detection and semantic segmentation. arxiv code
• 2014 | CGNA: Conditional Generative Adversarial Nets. arxiv code
• 2014 | DeepFaceVariant: Deep Learning Face Representation from Predicting 10,000 Classes. pdf code
• 2014 | GAN: Generative Adversarial Networks. arxiv code
• 2014 | GoogLeNet: Going Deeper with Convolutions. pdf code

More details in Model Zoo

Pre Trained Model

• Aligning the fastText vectors of 78 languages
• Available pretrained word embeddings
• Inception-v3 of imagenet
• Caffe2 Model Repository

More details in Pretrained Model

Courses

• [Berkeley] CS294: Deep Reinforcement Learning
• [Berkeley] Stat212b：Topics Course on Deep Learning
• [CUHK] ELEG 5040: Advanced Topics in Signal Processing(Introduction to Deep Learning)
• [CMU] Deep Reinforcement Learning and Control
• [CMU] Neural networks for NLP )

More details in courses

Books

• Deep Learning by Ian Goodfellow, Yoshua Bengio, and Aaron Courville. 中文版本
• Deep Learning Tutorial by LISA lab, University of Montreal
• Deep Learning Crash Course
• Documentation on all topics that I learn on both Artificial intelligence and machine learning.
• Interpretable Machine Learning
• Deep Learning and the Game of Go
• Deep Learning for Search
• Deep Learning with PyTorch
• Deep Reinforcement Learning in Action
• Grokking Deep Reinforcement Lerning
• Grokking Deep Learning for Computer Vision
• Probabilistic Deep Learning with Python
• Math and Architectures of Deep Learning
• Inside Deep Learning
• Engineering Deep Learning Platforms
• Deep Learning with R, Second Edition
• Regularization in Deep Learning
• Jax in Action
• Deep Learning with PyTorch, Second Edition
• Deep Learning with Python, Third Edition
• The RLHF Book
• Time Series Forecasting Using Foundation Models

More details in books

Tutorials

• UFLDL Tutorial 1
• UFLDL Tutorial 2
• Deep Learning for NLP (without Magic)
• A Deep Learning Tutorial: From Perceptrons to Deep Networks
• Deep Learning from the Bottom up
• Theano Tutorial
• TensorFlow tutorials
• Deep Learning with R in Motion
• Grokking Deep Learning in Motion
• Machine Learning, Data Science and Deep Learning with Python

More details in tutorials

Software

• Keras Deep Learning library for Theano and TensorFlow. ⭐
• Kur Descriptive Deep Learning. ⭐
• Caffe Deep learning framework by the BVLC ⭐
• CNTK The Microsoft Cognitive Toolkit.
• Dlib A modern C++ toolkit containing machine learning algorithms and tools for creating complex software in C++.
• PyTorch Tensors and Dynamic neural networks in Python with strong GPU acceleration. ⭐
• Scikit-Learn Machine learning in Python. ⭐
  • Semisup-Learn Semi-supervised learning frameworks for Python
• Tensorflow An open source software library for numerical computation using data flow graph by Google ⭐

More details in software

Applications

• pytorch

  • 2D and 3D Face alignment library build using pytorch
  • Adversarial Autoencoders
  • A implementation of WaveNet with fast generation
  • A fast and differentiable QP solver for PyTorch.
  • A method to generate speech across multiple speakers
  • A model for style-specific music generation ⭐
  • A natural language processing toolkit using state-of-the-art deep learning models. ⭐
  • 使用PyTorch实现Char RNN生成古诗和周杰伦的歌词

• theano

  • CNN-yelp-challenge-2016-sentiment-classification
  • Deep learning tutorial for PyData
  • Deep Neural Network for Sentiment Analysis on Twitter
  • Implementations of many popular deep learning models in Theano+Lasagne

• tensorflow

  • A generic image detection program that uses tensorflow and a pre-trained Inception.
  • All kinds of text classificaiton models and more with deep learning ⭐
  • Applying transfer learning to a custom dataset by retraining Inception's final layer
  • An easy implement of VGG19 with tensorflow, which has a detailed explanation.
  • An experimentation system for Reinforcement Learning using OpenAI Gym, Tensorflow, and Keras. ⭐
  • An implementation of Pix2Pix in Tensorflow for use with frames from films

• Keras

  • A DCGAN to generate anime faces using custom mined dataset
  • A facial expression classification system that recognizes 6 basic emotions: happy, sad, surprise, fear, anger and neutral.
  • A neural network trained to help writing neural network code using autocomplete
  • Attention mechanism Implementation for Keras.
  • Automated deep neural network design with genetic programming ⭐
  • Attention based Neural Machine Translation for Keras
  • Keras Implementation of Ladder Network for Semi-Supervised Learning

• Mxnet

  • 使用MXNet的动态图接口Gluon实现Char RNN生成古诗和周杰伦的歌词

More details in applications

Awesome Projects

• 15 AI and Machine Learning Events
• 188 examples of artificial intelligence in action
• A curated list of automated machine learning papers, articles, tutorials, slides and projects ⭐
• A curated list of awesome Machine Learning frameworks, libraries and software.
• A curated list of awesome places to learn and/or practice algorithms.
• A curated list of awesome R packages and tools
• A curated list of awesome SLAM tutorials, projects and communities.
• A curated list of resources dedicated to bridge between coginitive science and deep learning
• A curated list of resources dedicated to Natural Language Processing (NLP)
• A curated list of resources for NLP (Natural Language Processing) for Chinese
• Another curated list of deep learning resources
• A list of artificial intelligence tools you can use today
• A list of deep learning implementations in biology
• Awesome-2vec
• Awesome Action Recognition

More details in awesome projects

Corpus

• 用于对话系统的中英文语料
• 搜狗实验室
• 情感分析︱网络公开的免费文本语料训练数据集汇总
• 中文情感分析用词语集
• 人民日报切分/标注语料库
• 哈工大信息检索研究中心(HIT CIR)语言技术平台共享资源
• 中文句结构树资料库
• 中文对白语料 chinese conversation corpus
• 中文语料小数据：Some useful Chinese corpus datasets
• 中文人名语料库。中文姓名,姓氏,名字,称呼,日本人名,翻译人名,英文人名
• 联合国平行语料库
• 保险行业语料库
• 用于训练中英文对话系统的语料库 Datasets for Training Chatbot System
• PTT 八卦版問答中文語料
• 3 Million Instacart Orders, Open Sourced
• ACM Multimedia Systems Conference Dataset Archive
• A dataset for book recommendations: ten thousand books, one million ratings
• A dataset for personalized highlight detection
• A dataset of 200k English plaintext jokes.
• A large-scale and high-qualityFMA: A Dataset For Music Analysis dataset of annotated musical notes.
• A large-scale dataset of manually annotated audio events ⭐
• Alphabetical list of free/public domain datasets with text data for use in NLP

More details in corpus

Other Resources

• Synthical - AI-powered collaborative research environment. You can use it to get recommendations of articles based on reading history, simplify papers, find out what articles are trending, search articles by meaning (not just keywords), create and share folders of articles, see lists of articles from specific companies and universities, and so on.

from  https://github.com/endymecy/awesome-deeplearning-resources

一款实验性质的主机入侵检测系统驭龙HIDS

由于此项目缺少维护，建议仅用于参考学习和二次开发。

驭龙HIDS是一款由 YSRC 开源的入侵检测系统，由 Agent， Daemon， Server 和 Web 四个部分组成，集异常检测、监控管理为一体，拥有异常行为发现、快速阻断、高级分析等功能，可从多个维度行为信息中发现入侵行为。

Agent为采集者角色，收集服务器信息、开机启动项、计划任务、监听端口、服务、登录日志、用户列表，实时监控文件操作行为、网络连接、执行命令，初步筛选整理后通过RPC协议传输到Server节点。

Daemon为守护服务进程，为Agent提供进程守护、静默环境部署作用，其任务执行功能通过接收服务端的指令实现Agent热更新、阻断功能和自定义命令执行等，任务传输过程使用RSA进行加密。

Server为整套系统的大脑，支持横向扩展分布式部署，解析用户定义的规则（已内置部分基础规则）对从各Agent接收到的信息和行为进行分析检测和保存，可从各个维度的信息中发现webshell写入行为、异常登录行为、异常网络连接行为、异常命令调用行为等，从而实现对入侵行为实时预警。

文档

• 部署文档
• Docker快速体验部署文档
• 使用帮助
• 规则编写
• 编译指南
• Web安装向导指南
• Q&A

功能特点

• 实时监控、秒级响应
• 全局首次出现概念，可发现未知威胁
• 支持自定义规则，高扩展性
• 高级分析功能，可溯源
• 全局快速阻断（进程、文件）
• 威胁情报查询（可自定义接口）

相比其他同类应用，维护使用此系统需要有一定的安全判断分析能力。

 from https://github.com/ysrc/yulong-hids-archived

--------------------------------

 

编译指南

环境要求

Golang环境安装可以参照，各系统会与下面的示例稍有不同，Golang版本不可以低于1.9。

依赖

• Go依赖包都集成在相应工程的vendor目录中
• 编译Agent需要先安装libpcap-devel

Windows 下编译 Agent 需要 winpcap 支持。且受到 google/gopacket 影响可能会出现一些问题，具体请看 Q&A#Q1 Windows 下编译依赖gcc，可以通过mingw-w64 32位 64位安装

编译

客户端（Agent，Daemon、依赖）

• 下载安装对应安装包 https://golang.google.cn/dl/ 安装 golang
• windows 下编译需注意：32位版本须在 32 位版本 win7/2003 下编译。Win版本 agent 代码做了兼容，如只编译32位亦可在64位系统中正常工作
• go get github.com/ysrc/yulong-hids 之后在 {gopath}/src/github.com/ysrc/yulong-hids 下的项目编译后是会出现预期外异常的，请根据接下来的指导文档进行编译。

cd C:\Go\src
git clone https://github.com/ysrc/yulong-hids/

// 编译agent
go build -o yulong-hids\bin\win-64\agent.exe --ldflags="-w -s" yulong-hids\agent\agent.go

// 编译daemon
go build -o yulong-hids\bin\win-64\daemon.exe --ldflags="-w -s" yulong-hids\daemon\daemon.go

# linux 64
// 下载并解压
wget https://dl.google.com/go/go1.10.linux-amd64.tar.gz && tar -zxvf go1.10.linux-amd64.tar.gz -C /usr/local/

sudo vi /etc/profile 
// 并添加下面的内容：

export GOROOT=/usr/local/go
export GOBIN=$GOROOT/bin
export PATH=$PATH:$GOBIN
export GOPATH=$HOME/gopath (可选设置)

// 重新加载 profile 文件
source /etc/profile

cd /usr/local/go/src
git clone https://github.com/ysrc/yulong-hids/

// 编译agent
go build -o yulong-hids/bin/linux-64/agent --ldflags="-w -s" yulong-hids/agent/agent.go

// 编译daemon
go build -o yulong-hids/bin/linux-64/daemon --ldflags="-w -s" yulong-hids/daemon/daemon.go

编译后需压缩为不同系统的zip文件（如agent.exe、daemon.exe、data.zip），在向导过程中上传。
为了方便大家，我们提供了一个编译打包脚本，在build目录下运行 python3 build.py 就能编译并打包。
但是由于data.zip中提供的依赖文件不一定适配，可能需要你自行编译，所以这个文件需要手动打包进最终的部署包。

服务端（Server、Web）

go build -o yulong-hids/bin/server --ldflags="-w -s" yulong-hids/server/server.go
go build -o yulong-hids/web/web --ldflags="-w -s" yulong-hids/web/main.go

内核、驱动

win下的驭龙驱动文件pro.sys我们已经编译好了现成的放在了data.zip中，如果自行编译的话需要购买代码签名证书进行签名，否则无法正常加载使用。

下载地址：wdk 7600

// win驱动
准备2008或win7 x64系统，安装 GRMWDK 7600。
从开始菜单中选择进入对应系统的控制台，如
Windows Driver Kits->WDK 7600.16385.1->Build Environments->Windows Vista and Windows Server 2008->x64 Checked
Build Environment
具体根据你的系统选择Build Environments，要编译32位的就选x86。

cd C:\Go\src\yulong-hids\driver\
build

// Linux内核
我们在bin\linux-64\data.zip中已经提供了一些编译好的对应内核版本的ko文件，直接用的话需要确认内核版本完全一致。
实际部署过程中需要 uname -r 统计下需要部署的机器linux内核版本，然后需要找到完全匹配对应版本的kernel-devel包
下下来并安装，yum安装的不一定完全匹配。虽然软链接到不一致的版本也能编译出来ko并加载，但是不知道会不会有影响，
稳妥起见还是参照上面的做法。
rpm -ivh kernel-devel-3.10.0-327.el7.x86_64.rpm

debian系的也类似 用 uname -r 的结果替换 4.9.0-3-amd64 
apt-get install linux-headers-4.9.0-3-amd64

openSUSE
zypper install kernel-devel

安装好对应kernel-devel包后cd进目录就可以编译了
cd /usr/local/go/src/yulong-hids/syscall_hook
make

编译好的内核和驱动需要替换进对应系统目录下的data.zip内。

驱动签名的我们给两个示例，具体命令会因证书商不一样而稍有不同。

signtool sign /v /ac "MSCV-ThawteClass3.cer" /a /s MY /n "Tongcheng Network Technology Co., Ltd" /fd sha256 /tr http://sha256timestamp.ws.symantec.com/sha256/timestamp/ "e:\pro.sys"

signtool sign /v /ac "DigiCert High Assurance EV Root CA.crt" /tr http://timestamp.digicert.com /td sha256 /fd sha256 /f "e:\sha256new.p12" /p 证书密码 "e:\pro.sys"

 from https://github.com/ysrc/yulong-hids-archived/blob/master/docs/build.md

 

installing Calico

  installing Calico for policy and flannel for networking for up to date installation directions and manifests. 

 

docker-gocd-server

 Docker server image for GoCD。

 https://hub.docker.com/r/gocd/gocd-server/

GoCD Server Container image

A Wolfi-based container image for GoCD server.

Issues, feedback?

Please make sure to log them at https://github.com/gocd/gocd.

Usage

Start the container with this:

docker run -d -p8153:8153 gocd/gocd-server:v26.1.0

This will expose container port 8153 (http) onto your server. You can now open http://localhost:8153

Available configuration options

Mounting volumes

The GoCD server will store all configuration, pipeline history database, artifacts, plugins, and logs into /godata. If you'd like to provide secure credentials like SSH private keys among other things, you can mount /home/go

docker run -v /path/to/godata:/godata -v /path/to/home-dir:/home/go gocd/gocd-server:v26.1.0

Note: Ensure that /path/to/home-dir and /path/to/godata is accessible by the go user in container (go user - uid 1000).

Installing plugins

All plugins can be installed under /godata.

Installing plugins using an environment configuration

To install plugins, just add an ENV variable with the prefix GOCD_PLUGIN_INSTALL_ and your name as suffix and the value being the download URL. The plugin will only be downloaded if not yet present.

An example example would be GOCD_PLUGIN_INSTALL_docker-elastic-agents=https://github.com/gocd-contrib/docker-elastic-agents/releases/download/v0.8.0/docker-elastic-agents-0.8.0.jar:

docker run \
  -e GOCD_PLUGIN_INSTALL_docker-elastic-agents=https://github.com/gocd-contrib/docker-elastic-agents/releases/download/v0.8.0/docker-elastic-agents-0.8.0.jar \
  gocd/gocd-server:v26.1.0

To install multiple plugins, add several -e arguments as such:

docker run \
  -e GOCD_PLUGIN_INSTALL_a-plugin=https://example.com/a-plugin.jar \
  -e GOCD_PLUGIN_INSTALL_b-plugin=https://example.com/b-plugin.jar \
  gocd/gocd-server:v26.1.0

Installing plugins using a custom entry-point script (see below)

mkdir -p /godata/plugins/external
curl --location --fail https://example.com/plugin.jar > /path/to/godata/plugins/external/plugin.jar
chown -R 1000 /godata/plugins/external

Loading configuration from existing git repo

To load existing configuration from git repo, just add an ENV variable CONFIG_GIT_REPO. Auth token may be used to access private repo. Branch master would be cloned by default. To load another branch, define an ENV variable CONFIG_GIT_BRANCH. If /godata/config already is git repo then CONFIG_GIT_REPO will be ignored. Cloned repo must contain all files from /godata/config dir.

docker run \
  -e CONFIG_GIT_REPO=https://gocd_user:password_or_auth_token/config.git \
  -e CONFIG_GIT_BRANCH=branch_with_config \
  gocd/gocd-server:v26.1.0

Checkouted content would overwrite files in /godata/config/.

Running custom entrypoint scripts

To execute custom script(s) during the container boostrap, but before the GoCD server starts just add -v /path/to/your/script.sh:/docker-entrypoint.d/your-script.sh like so:

docker run -v /path/to/your/script.sh:/docker-entrypoint.d/your-script.sh ... gocd/gocd-server:v26.1.0

If you have several scripts in a directory that you'd like to execute:

docker run -v /path/to/script-dir:/docker-entrypoint.d ... gocd/gocd-server:v26.1.0

Note: Ensure that your scripts are executable chmod a+x — you can add as many scripts as you like, bash is available on the container. If your script uses other scripting language (perl, python), please ensure that the scripting language is installed in the container.

Tweaking JVM options (memory, heap etc)

JVM options can be tweaked using the environment variable GOCD_SERVER_JVM_OPTS.

docker run -e GOCD_SERVER_JVM_OPTS="-Xmx4096mb -Dfoo=bar" gocd/gocd-server:v26.1.0

Under the hood

The GoCD server runs as the go user, the location of the various directories is:

Directory	Description
/godata/artifacts	the directory where GoCD artifacts are stored
/godata/config	the directory where the GoCD configuration is stored
/godata/db	the directory where the GoCD database and configuration change history is stored
/godata/logs	the directory where GoCD logs will be written out to
/godata/plugins	the directory containing GoCD plugins
/home/go	the home directory for the GoCD server

Determine Server IP and Ports on Host

Once the GoCD server is up, we should be able to determine its ip address and the ports mapped onto the host by doing the following: The IP address and ports of the GoCD server in a docker container are important to know as they will be used by the GoCD agents to connect to it. If you have started the container with

docker run --name server -it -p8153:8153 gocd/gocd-server:v26.1.0

Then, the below commands will determine to GoCD server IP, server port and ssl port

docker inspect --format='{{(index (index .NetworkSettings.IPAddress))}}' server
docker inspect --format='{{(index (index .NetworkSettings.Ports "8153/tcp") 0).HostPort}}' server

Troubleshooting

The GoCD server does not come up

• Check if the docker container is running docker ps -a
• Check the STDOUT to see if there is any output that indicates failures docker logs CONTAINER_ID
• Check the server logs docker exec -it CONTAINER_ID tail -f /godata/logs/go-server.log (or check the log file in the volume mount, if you're using one)

from  https://github.com/gocd/docker-gocd-server

Spinnaker

 

Spinnaker is an open source, multi-cloud continuous delivery platform for releasing software changes with high velocity and confidence.

www.spinnaker.io/

 

Welcome to the Spinnaker Project

Spinnaker is an open-source continuous delivery platform for releasing software changes with high velocity and confidence. Spinnaker provides a single platform that allows you to safely deploy and manage your application in multiple cloud environments (AWS, GCP, Kubernetes and more!). With automated canary analysis and multiple ways to initiate deployments, you can safely promote your code from a git commit into a dev environment all the way through multiple production environments with confidence in the results. Spinnaker is the most mature and widely productionalized continuous delivery platform built upon the work of Netflix, Google, Microsoft, Amazon and numerous other companies to allow fast, safe deploys. Used by numerous organizations including Target, Salesforce, Airbnb, Cerner, Adobe, JPMorgan Chase and more!

Project status and updates

Note that this repo is only used for issue tracking across the various services at this time. Releases are not managed here nor are updates regularly made to this repository. Please see the following for more information about spinnaker and it’s state:

• Current available versions

• The spinnaker slack for help and discussions around spinnaker

• Issues page for bug reports, enhancements and similar

• Governance for the project as a whole There is a lot of activity and we’d welcome participation!

More about spinnaker

Manage your SDLC in Spinnaker using the GUI (graphical user interface), or config-as-code. View, manage, and construct application workflows involving one or all of these resources:

• Virtual machine (VM) deployments to a public cloud provider, "baked" as immutable infrastructure

• Container deployments to a cloud

• Container deployments to Kubernetes

• Load balancers

• Security groups

• Server groups

• Clusters

• Firewalls

• Functions

Facilitate GitOps, and grant developers control of provisioning infrastructure for apps. Use Spinnaker’s Clouddriver to deploy to all of the major public cloud providers and Kubernetes. You may even orchestrate configuration and firmware changes as part of Spinnaker delivery pipelines.

Why Do I Need Spinnaker?

Use Spinnaker to create a “paved road” for application delivery, with guardrails that ensure only valid infrastructure and configuration reach production.

Free development teams from burdensome ops provisioning while automating reinforcement of business and regulatory requirements. Delivery automation strategies such as canary deployments provide the safety necessary to capture value from quick innovation, while protecting against business and end-user impact.

Tech Specs

Spinnaker consists of a number of independent microservices, with the Halyard CLI tool or the Kubernetes Operator (Beta) managing the lifecycle of the other services. A variety of SDLC tools integrate with Spinnaker, and its plugin framework makes Spinnaker more easily customizable to your needs. Plugins allow us to add system integrations without updating Spinnaker, broadening its potential to easily leverage the entire software delivery toolchain. With this in place, Spinnaker is evolving towards a smaller threat surface, enabling performance and operational advantages. Meanwhile, managed delivery, a newer Spinnaker featureset, provides declarative definitions of common infrastructure and other requirements; users can declare requirements using those prebuilt definitions and move changes through environments via a visual interface.

---

This repository centralizes issue tracking across Spinnaker for each microservice. The core code making up Spinnaker’s microservices is found in the other Spinnaker repositories.

Using Spinnaker

Spinnaker users should refer to the main Spinnaker site and Installation guide.

For more information on how Spinnaker is designed, see the Concepts topic in the documentation Overview.

If you’re interested in a detailed walkthrough of the Spinnaker systems, check the Spinnaker How-to guides, videos, and codelabs.

Setting Up Spinnaker For Development

To pull Spinnaker from source and set it up to run locally against any of the Cloud Providers, follow the Developer Setup Guide

FROM  https://github.com/spinnaker/spinnaker

velero, Backup and migrate Kubernetes applications

 

Backup and migrate Kubernetes applications and their persistent volumes.

velero.io

 

Overview

Velero (formerly Heptio Ark) gives you tools to back up and restore your Kubernetes cluster resources and persistent volumes. You can run Velero with a public cloud platform or on-premises.

Velero lets you:

• Take backups of your cluster and restore in case of loss.
• Migrate cluster resources to other clusters.
• Replicate your production cluster to development and testing clusters.

Velero consists of:

• A server that runs on your cluster
• A command-line client that runs locally

Documentation

The documentation provides a getting started guide and information about building from source, architecture, extending Velero and more.

Please use the version selector at the top of the site to ensure you are using the appropriate documentation for your version of Velero.

Troubleshooting

If you encounter issues, review the troubleshooting docs, file an issue, or talk to us on the #velero-users and #velero-dev channel on the Kubernetes Slack server.

Community

Velero is an open community and we welcome your participation. The best way to get involved is to join our bi-weekly community meetings:

• Join the Velero community meetings, held bi-weekly, alternating between Beijing-friendly and US/Europe-friendly time zones.
• Subscribe to the project meeting calendar.
• Chat with us on the Kubernetes Slack #velero-users channel and join the mailing list.

See the community page for the full schedule and details.

from  https://github.com/velero-io/velero

OfficeCLI

OfficeCLI is the world's first and the best Office suite designed for AI agents.

Give any AI agent full control over Word, Excel, and PowerPoint — in one line of code.

Open-source. Single binary. No Office installation. No dependencies. Works everywhere.

OfficeCLI's built-in HTML rendering engine reproduces documents with high fidelity — and that's what gives AI eyes. It renders .docx / .xlsx / .pptx to HTML or PNG, closing the render → look → fix loop.

 

English | 中文 | 

🌐 Website: officecli.ai  |  💬 Community: Discord

PPT creation process using OfficeCLI on AionUi

PowerPoint Presentations

—

Word Documents

—

Excel Spreadsheets

All documents above were created entirely by AI agents using OfficeCLI — no templates, no manual editing.

For AI Agents — Get Started in One Line

Paste this into your AI agent's chat — it will read the skill file and install everything automatically:

curl -fsSL https://officecli.ai/SKILL.md

That's it. The skill file teaches the agent how to install the binary and use all commands.

For Humans

Option A — GUI: Install AionUi — a desktop app that lets you create and edit Office documents through natural language, powered by OfficeCLI under the hood. Just describe what you want, and AionUi handles the rest.

Option B — CLI: Download the binary for your platform from GitHub Releases, then run:

officecli install

This copies the binary to your PATH and installs the officecli skill into every AI coding agent it detects — Claude Code, Cursor, Windsurf, GitHub Copilot, and more. Your agent can immediately create, read, and edit Office documents on your behalf, no extra configuration needed.

For Developers — See It Live in 30 Seconds

# 1. Install (macOS / Linux) — or: brew install officecli / npm install -g @officecli/officecli
curl -fsSL https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.sh | bash
# Windows (PowerShell): irm https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.ps1 | iex

# 2. Create a blank PowerPoint
officecli create deck.pptx

# 3. Start live preview — opens http://localhost:26315 in your browser
officecli watch deck.pptx

# 4. Open another terminal, add a slide — watch the browser update instantly
officecli add deck.pptx / --type slide --prop title="Hello, World!"

That's it. Every add, set, or remove command you run will refresh the preview in real time. Keep experimenting — the browser is your live feedback loop.

Quick Start

# Create a presentation and add content
officecli create deck.pptx
officecli add deck.pptx / --type slide --prop title="Q4 Report" --prop background=1A1A2E
officecli add deck.pptx '/slide[1]' --type shape \
  --prop text="Revenue grew 25%" --prop x=2cm --prop y=5cm \
  --prop font=Arial --prop size=24 --prop color=FFFFFF

# View as outline
officecli view deck.pptx outline
# → Slide 1: Q4 Report
# →   Shape 1 [TextBox]: Revenue grew 25%

# View as HTML — opens a rendered preview in your browser, no server needed
officecli view deck.pptx html

# Get structured JSON for any element
officecli get deck.pptx '/slide[1]/shape[1]' --json

# Save and close — flushes the resident session to disk
officecli close deck.pptx

{
  "tag": "shape",
  "path": "/slide[1]/shape[1]",
  "attributes": {
    "name": "TextBox 1",
    "text": "Revenue grew 25%",
    "x": "720000",
    "y": "1800000"
  }
}

、

、

、

例子：officecli add deck.pptx / --type slide --prop title="Q4 Report"

What OfficeCLI can do:

• Create documents from scratch -- blank or with content
• Read text, structure, styles, formulas -- in plain text or structured JSON
• Analyze formatting issues, style inconsistencies, and structural problems
• Modify any element -- text, fonts, colors, layout, formulas, charts, images
• Reorganize content -- add, remove, move, copy elements across documents

Format	Read	Modify	Create
Word (.docx)	✅	✅	✅
Excel (.xlsx)	✅	✅	✅
PowerPoint (.pptx)	✅	✅	✅

Word — full i18n & RTL support (per-script font slots, per-script BCP-47 lang tags lang.latin/ea/cs, complex-script bold/italic/size, direction=rtl cascading through paragraph/run/section/table/style/header/footer/docDefaults, rtlGutter + pgBorders shorthand, locale-aware page numbering for Hindi/Arabic/Thai/CJK; create --locale ar-SA auto-enables RTL), paragraphs (framePr, tabs shorthand, char-based indents), runs (underline.color, position half-pts), tables (virtual column ops add/remove/move/copyfrom, hMerge), styles, textbox / shape (textbox: rotation, textDirection eaVert/vert270, gradient, shadow, opacity), headers/footers, images (PNG/JPG/GIF/SVG), equations (LaTeX input), diagrams (mermaid → native editable shapes, or any mermaid type as a full-fidelity PNG), comments, footnotes, watermarks, bookmarks, TOC, charts, hyperlinks, sections, form fields, content controls (SDT), fields (22 zero-param types + MERGEFIELD / REF / PAGEREF / SEQ / STYLEREF / DOCPROPERTY / IF), OLE objects, revisions / tracked changes (revision.type=ins\|del\|format\|moveFrom\|moveTo + revision.action=accept\|reject, per-target /revision[@author=Alice] selector, tracked Find&Replace), page background color, document properties

Excel — cells (phonetic guide / furigana on add, Excel-UI --shift left\|up on remove / shift=right\|down on add), formulas (350+ built-in functions with auto-evaluation, spilling dynamic arrays with _xlfn. auto-prefix, financial / bond and statistical families, OFFSET/INDIRECT, defined-name formula bodies inlined at parse, formula-ref rewrite on row/col insert), sheets (visible/hidden/veryHidden, print margins, printTitleRows/Cols, RTL sheetView, cascade-aware sheet rename, empty-cell bloat filter on open), boolean and/or selectors (row[Salary>5000 and Region=EMEA]), tables, sort (sheet / range, multi-key, sidecar-aware), conditional formatting, charts (including box-whisker, pareto with auto-sort + cumulative-%, log axis), pivot tables (multi-field, date grouping, showDataAs, sort, grandTotals, subtotals, compact/outline/tabular layout, repeat item labels, blank rows, calculated fields, persistent labelFilter / topN filters, cache CoW + cross-pivot sharing), slicers, named ranges, data validation, images (PNG/JPG/GIF/SVG with dual-representation fallback), sparklines, comments (RTL), autofilter, shapes, OLE objects, CSV/TSV import, $Sheet:A1 cell addressing

PowerPoint — slides (header/footer/date/slidenum toggles, hidden), shapes (pattern fill, blur effect, hyperlink tooltip + slide-jump links, highlight color on runs, slideMaster/slideLayout typed add/set/remove, arrow alias, effective.X + effective.X.src), images (PNG/JPG/GIF/SVG, fill modes: stretch/contain/cover/tile, brightness/contrast/glow/shadow, rotation, link + tooltip), tables (built-in PowerPoint style catalogue, virtual /col[C] get + swap/copyFrom, row/col Move/CopyFrom, fill/background alias), charts (pieOfPie, barOfPie, per-attr axisLine/gridline setters, series add/remove with theme palette, anchor=x,y,w,h shorthand), animations (15 emphasis + 16 exit template-backed presets, multi-effect chains, motion-path presets, repeat/restart/autoReverse, chart animations + chartBuild), transitions (morph + p14 + 12 p15 PowerPoint 2013+ presets), 3D models (.glb) (combined rotation=ax,ay,az), slide zoom, equations (LaTeX input), diagrams (mermaid flowchart / sequence → native editable shapes, or any mermaid type as a full-fidelity PNG), themes, connectors (from/to accept a full /slide[N]/shape[@name=Foo] path), video/audio (loop, autoStart), groups (link + tooltip; Get/Query/Add/Remove all descend into groups), notes (RTL, lang), comments (RTL, legacy + modern p188 threaded round-trip), SmartArt (round-trip via add-part + raw-set), OLE objects, placeholders (add/set by phType)

Use Cases

For Developers:

• Automate report generation from databases or APIs
• Batch-process documents (bulk find/replace, style updates)
• Build document pipelines in CI/CD environments (generate docs from test results)
• Headless Office automation in Docker/containerized environments

For AI Agents:

• Generate presentations from user prompts (see examples above)
• Extract structured data from documents to JSON
• Validate and check document quality before delivery

For Teams:

• Clone document templates and populate with data
• Automated document validation in CI/CD pipelines

Installation

Ships as a single self-contained binary. The .NET runtime is embedded -- nothing to install, no runtime to manage.

One-line install:

# macOS / Linux
curl -fsSL https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.sh | bash

# Windows (PowerShell)
irm https://raw.githubusercontent.com/iOfficeAI/OfficeCLI/main/install.ps1 | iex

Or via a package manager:

# Homebrew (macOS / Linux)
brew install officecli

# Scoop (Windows)
scoop install officecli

# npm (all platforms — fetches the native binary for your platform)
npm install -g @officecli/officecli

Or download manually from GitHub Releases:

Platform	Binary
macOS Apple Silicon	officecli-mac-arm64
macOS Intel	officecli-mac-x64
Linux x64	officecli-linux-x64
Linux ARM64	officecli-linux-arm64
Windows x64	officecli-win-x64.exe
Windows ARM64	officecli-win-arm64.exe

Verify installation: officecli --version

Or self-install from a downloaded binary (or run bare officecli to auto-install):

officecli install    # explicit
officecli            # bare invocation also triggers install

Updates are checked automatically in the background. Disable with officecli config autoUpdate false or skip per-invocation with OFFICECLI_SKIP_UPDATE=1. Configuration lives under ~/.officecli/config.json.

Key Features

Built-in Engines & Generation Primitives

OfficeCLI is self-contained. The capabilities below ship inside the binary — no Office required.

Rendering engine — high-fidelity, built-in

OfficeCLI's keystone: a from-scratch, high-fidelity HTML rendering engine that lets an AI agent see the rendered document instead of guessing from the DOM. It covers shapes, charts (trendlines, error bars, waterfall, candlestick, sparklines), equations (OMML → LaTeX, rendered with KaTeX), 3D .glb models via Three.js, morph transitions, slide zoom, and shape effects. Per-page PNG screenshots are produced by piping the rendered HTML through a headless browser. Three modes:

• view html — standalone HTML file, assets inlined. Open in any browser.
• view screenshot — per-page PNG, ready for multimodal agents to read.
• watch — local HTTP server with auto-refreshing preview; every add / set / remove updates the browser instantly. Excel watch supports inline cell editing and drag-to-reposition charts.

officecli view deck.pptx html -o /tmp/deck.html
officecli view deck.pptx screenshot -o /tmp/deck.png # add --page 1-N for more slides
officecli watch deck.pptx                            # http://localhost:26315

Without visualization, an agent generating slides is flying blind — it can read the DOM but can't tell if the title overflows or two shapes overlap. Because rendering is built into the binary, the render → look → fix loop works in CI, in Docker, on a server with no display — anywhere the binary runs.

Formula & pivot engine

350+ built-in Excel functions evaluated automatically on write — write =SUM(A1:A2), get the cell, the value is already there. No round-trip through Office to recalc. Covers spilling dynamic arrays (FILTER / SORT / UNIQUE / SEQUENCE / LET / LAMBDA / MAP), VLOOKUP / XLOOKUP / INDEX / MATCH, financial & bond math (XIRR / PRICE / YIELD / DURATION / COUPNUM), statistical distributions, tests & regression (NORM.DIST / T.TEST / LINEST), and date & text functions.

Plus native OOXML pivot tables from a source range with one command — multi-field rows/cols/filters, 10 aggregations, showDataAs modes, date grouping, calculated fields, top-N, layouts. Pivot cache + definition are written to OOXML, so Excel opens the file with the aggregation already populated:

officecli add sales.xlsx '/Sheet1' --type pivottable \
  --prop source='Data!A1:E10000' --prop rows='Region,Category' \
  --prop cols=Quarter --prop values='Revenue:sum,Units:avg' \
  --prop showDataAs=percentOfTotal

Template merge — generate once, fill many

merge replaces {{key}} placeholders in any .docx / .xlsx / .pptx with JSON data — across paragraphs, table cells, shapes, headers, footers, and chart titles. Agent designs the layout once (expensive); production code fills it N times (cheap, deterministic, zero token cost). Avoids the failure mode where an agent regenerates each report from scratch and produces N inconsistent layouts.

officecli merge invoice-template.docx out-001.docx --data '{"client":"Acme","total":"$5,200"}'
officecli merge q4-template.pptx q4-acme.pptx --data data.json

Round-trip dump — learn from existing docs

dump serializes any .docx, .pptx, or .xlsx — whole document or any subtree (a single paragraph, table, slide, worksheet, the styles part, numbering, theme, or settings) — into a replayable batch JSON; batch replays it. Given a sample the user wants to imitate, an agent reads the structured spec instead of raw OOXML XML, mutates, and replays. Bridges "I have an existing template" and "generate me 100 variations."

officecli dump existing.docx -o blueprint.json                  # whole document
officecli dump existing.docx /body/tbl[1] -o table.json         # any subtree
officecli dump existing.xlsx /Sheet1 -o sheet.json              # a single worksheet
officecli batch new.docx --input blueprint.json

Resident Mode & Batch

For multi-step workflows, resident mode keeps the document in memory. Batch mode applies multiple operations in a single pass.

# Resident mode — near-zero latency via named pipes
officecli open report.docx
officecli set report.docx /body/p[1]/r[1] --prop bold=true
officecli set report.docx /body/p[2]/r[1] --prop color=FF0000
officecli close report.docx

# Batch mode — multi-command execution (atomic by default: any failed item rolls back the whole batch)
echo '[{"command":"set","path":"/slide[1]/shape[1]","props":{"text":"Hello"}},
      {"command":"set","path":"/slide[1]/shape[2]","props":{"fill":"FF0000"}}]' \
  | officecli batch deck.pptx --json

# Inline batch with --commands (no stdin needed)
officecli batch deck.pptx --commands '[{"op":"set","path":"/slide[1]/shape[1]","props":{"text":"Hi"}}]'

# Keep whatever succeeds even if some items fail (pre-1.0.137 behavior)
officecli batch deck.pptx --input updates.json --best-effort --json

# Stop at the first failing command instead of running the rest (still rolls back everything unless combined with --best-effort)
officecli batch deck.pptx --input updates.json --stop-on-error --json

Reading the file with another tool? Flush to disk first. officecli's own reads (get/query/view) always see your latest edits, so within officecli you never need to save. But a live resident defers the disk write, so before a non‑officecli program reads the file — python‑docx/openpyxl, Microsoft Word, a renderer, delivery/upload — flush it:

officecli set report.docx /body/p[1] --prop bold=true
officecli save report.docx           # flush, keep the resident warm (or `close` to flush + release)
python my_reader.py report.docx      # now sees the edit

A live resident also auto‑flushes shortly after going idle (adaptive 2–10s, scaled to the document's measured save cost). For a pipeline where another program reads after every command, set OFFICECLI_RESIDENT_FLUSH=each — every mutation is on disk before the command returns, while the resident stays warm. Full flush model (each/auto/fixed/off, save / close, env tuning): wiki → open / close.

Three-Layer Architecture

Start simple, go deep only when needed.

Layer	Purpose	Commands
L1: Read	Semantic views of content	view (text, annotated, outline, stats, issues, html, svg, screenshot)
L2: DOM	Structured element operations	get, query, set, add, remove, move, swap
L3: Raw XML	Direct XPath access — universal fallback	raw, raw-set, add-part, validate

# L1 — high-level views
officecli view report.docx annotated
officecli view budget.xlsx text --cols A,B,C --max-lines 50

# L2 — element-level operations
officecli query report.docx "run:contains(TODO)"
officecli add budget.xlsx / --type sheet --prop name="Q2 Report"
officecli move report.docx /body/p[5] --to /body --index 1

# L3 — raw XML when L2 isn't enough
officecli raw deck.pptx '/slide[1]'
officecli raw-set report.docx document \
  --xpath "//w:p[1]" --action append \
  --xml '<w:r><w:t>Injected text</w:t></w:r>'

AI Integration

MCP Server

Built-in MCP server — register with one command:

officecli mcp claude       # Claude Code
officecli mcp cursor       # Cursor
officecli mcp vscode       # VS Code / Copilot
officecli mcp lmstudio     # LM Studio
officecli mcp list         # Check registration status

Exposes all document operations as tools over JSON-RPC — no shell access needed.

Direct CLI Integration

Get OfficeCLI working with your AI agent in two steps:

1. Install the binary -- one command (see Installation)
2. Done. OfficeCLI automatically detects your AI tools (Claude Code, GitHub Copilot, Codex) by checking known config directories and installs its skill file. Your agent can immediately create, read, and modify any Office document.

Manual setup (optional)

Why your agent will thrive on OfficeCLI

• Deterministic JSON output — every command supports --json with consistent schemas. No regex parsing, no scraping stdout.
• Path-based addressing — every element has a stable path (/slide[1]/shape[2]). Agents navigate documents without understanding XML namespaces. (OfficeCLI syntax: 1-based indexing, element local names — not XPath.)
• Progressive complexity (L1 → L2 → L3) — agents start with read-only views, escalate to DOM ops, fall back to raw XML only when needed. Minimizes token usage.
• Self-healing workflow — validate, view issues, and the structured error codes (not_found, invalid_value, unsupported_property) return suggestions and valid ranges. Agents self-correct without human intervention.
• Built-in agent-friendly rendering engine — view html / view screenshot / watch emit HTML and PNG natively. No Office required. Agents can see their output and fix layout issues, even inside CI / Docker / headless environments.
• Built-in formula & pivot engine — 350+ Excel functions auto-evaluated on write (incl. spilling dynamic arrays, financial / bond and statistical families); native OOXML pivot tables from a source range with one command. Agents read computed values and shipped aggregations immediately, without round-tripping through Office.
• Template merge — agent designs the layout once, downstream code fills {{key}} placeholders N times. Avoids burning tokens regenerating every report from scratch.
• Round-trip dump — dump turns any .docx, .pptx, or .xlsx into replayable batch JSON. Agents learn from human-authored samples by reading a structured spec, not raw OOXML XML.
• Built-in help — when unsure about property names or value formats, the agent runs officecli <format> set <element> instead of guessing.
• Auto-install — OfficeCLI detects your AI tooling (Claude Code, Cursor, VS Code, …) and configures itself. No manual skill-file setup.

Built-in Help

Don't guess property names — drill into the help:

officecli help pptx set              # All settable elements and properties
officecli help pptx set shape        # Detail for one element type
officecli help docx query            # Selector reference: attributes, :contains, :has(), etc.

Run officecli --help for the full overview.

JSON Output Schemas

All commands support --json. The general response shapes:

Single element (get --json):

{"tag": "shape", "path": "/slide[1]/shape[1]", "attributes": {"name": "TextBox 1", "text": "Hello"}}

List of elements (query --json):

[
  {"tag": "paragraph", "path": "/body/p[1]", "attributes": {"style": "Heading1", "text": "Title"}},
  {"tag": "paragraph", "path": "/body/p[5]", "attributes": {"style": "Heading1", "text": "Summary"}}
]

Errors return a non-zero exit code with a structured error object including error code, suggestion, and valid values when available:

{
  "success": false,
  "error": {
    "error": "Slide 50 not found (total: 8)",
    "code": "not_found",
    "suggestion": "Valid Slide index range: 1-8"
  }
}

Error codes: not_found, invalid_value, unsupported_property, invalid_path, unsupported_type, missing_property, file_not_found, file_locked, invalid_selector. Property names are auto-corrected -- misspelling a property returns a suggestion with the closest match.

Error Recovery -- Agents self-correct by inspecting available elements:

# Agent tries an invalid path
officecli get report.docx /body/p[99] --json
# Returns: {"success": false, "error": {"error": "...", "code": "not_found", "suggestion": "..."}}

# Agent self-corrects by checking available elements
officecli get report.docx /body --depth 1 --json
# Returns the list of available children, agent picks the right path

Mutation confirmations (set, add, remove, move, create with --json):

{"success": true, "path": "/slide[1]/shape[1]"}

See officecli --help for full details on exit codes and error formats.

Comparison

	OfficeCLI	Microsoft Office	LibreOffice	python-docx / openpyxl
Open source & free	✓ (Apache 2.0)	✗ (paid license)	✓	✓
AI-native CLI + JSON	✓	✗	✗	✗
Zero install (single binary)	✓	✗	✗	✗ (Python + pip)
Call from any language	✓ (CLI)	✗ (COM/Add-in)	✗ (UNO API)	Python only
Path-based element access	✓	✗	✗	✗
Raw XML fallback	✓	✗	✗	Partial
Built-in agent-friendly rendering engine	✓	✗	✗	✗
Headless HTML/PNG output	✓	✗	Partial	✗
Template merge ({{key}}) across formats	✓	✗	✗	✗
Round-trip dump → batch JSON	✓	✗	✗	✗
Live preview (auto-refresh on edit)	✓	✗	✗	✗
Headless / CI	✓	✗	Partial	✓
Cross-platform	✓	Windows/Mac	✓	✓
Word + Excel + PowerPoint	✓	✓	✓	Separate libs

Command Reference

Command	Description
create	Create a blank .docx, .xlsx, or .pptx (type from extension)
view	View content (modes: outline, text, annotated, stats (--page-count), issues, html, svg, screenshot, pdf (via exporter plugin), forms (via format-handler plugin)). docx supports --render auto|native|html.
load_skill	Print embedded SKILL.md content for a specialized skill (no install)
get	Get element and children (--depth N, --json)
query	CSS-like query with boolean and/or, row-by-column-name (row[Salary>5000]), --find flag
set	Modify element properties; accepts selectors and Excel-native paths (parity with get/query), --find/--replace flags
add	Add element (or clone with --from <path>)
remove	Remove an element
move	Move element (--to <parent>, --index N, --after <path>, --before <path>)
swap	Swap two elements
validate	Validate against OpenXML schema
view <file> issues	Enumerate document issues (text overflow, missing alt text, formula errors, ...)
batch	Multiple operations applied in a single pass (stdin, --input, or --commands; atomic by default — any failed item rolls back the whole batch — --best-effort to keep partial progress, --stop-on-error to abort early)
dump	Serialize a .docx, .pptx, or .xlsx into a replayable batch JSON (round-trip via batch); accepts a subtree path
refresh	Recalculate TOC page numbers / PAGE / cross-references (.docx; Word backend on Windows, headless-HTML fallback)
plugins	List / inspect / lint installed plugins (extend to .doc, .hwpx, .pdf export via dump-reader / exporter / format-handler kinds)
merge	Template merge — replace {{key}} placeholders with JSON data
watch	Live HTML preview in browser with auto-refresh
mcp	Start MCP server for AI tool integration
raw	View raw XML of a document part
raw-set	Modify raw XML via XPath
add-part	Add a new document part (header, chart, etc.)
open	Start resident mode (keep document in memory)
close	Save and close resident mode
install	Install binary + skills + MCP (all, claude, cursor, etc.)
config	Get or set configuration
help <format> <command>	Built-in help (e.g. officecli help pptx set shape)

End-to-End Workflow Example

A typical self-healing agent workflow: create a presentation, populate it, verify, and fix issues -- all without human intervention.

# 1. Create
officecli create report.pptx

# 2. Add content
officecli add report.pptx / --type slide --prop title="Q4 Results"
officecli add report.pptx '/slide[1]' --type shape \
  --prop text="Revenue: $4.2M" --prop x=2cm --prop y=5cm --prop size=28
officecli add report.pptx / --type slide --prop title="Details"
officecli add report.pptx '/slide[2]' --type shape \
  --prop text="Growth driven by new markets" --prop x=2cm --prop y=5cm

# 3. Verify
officecli view report.pptx outline
officecli validate report.pptx

# 4. Fix any issues found
officecli view report.pptx issues --json
# Address issues based on output, e.g.:
officecli set report.pptx '/slide[1]/shape[1]' --prop font=Arial

Units & Colors

All dimension and color properties accept flexible input formats:

Type	Accepted formats	Examples
Dimensions	cm, in, pt, px, or raw EMU	2cm, 1in, 72pt, 96px, 914400
Colors	Hex, named, RGB, theme	#FF0000, FF0000, red, rgb(255,0,0), accent1
Font sizes	Bare number or pt-suffixed	14, 14pt, 10.5pt
Spacing	pt, cm, in, or multiplier	12pt, 0.5cm, 1.5x, 150%

Common Patterns

# Replace all Heading1 text in a Word doc
officecli query report.docx "paragraph[style=Heading1]" --json | ...
officecli set report.docx /body/p[1]/r[1] --prop text="New Title"

# Export all slide content as JSON
officecli get deck.pptx / --depth 2 --json

# Bulk-update Excel cells
officecli batch budget.xlsx --input updates.json --json

# Import CSV data into an Excel sheet
officecli add budget.xlsx / --type sheet --prop name="Q1 Data"
officecli import budget.xlsx "/Q1 Data" sales.csv --header

# Template merge for batch reports
officecli merge invoice-template.docx invoice-001.docx --data '{"client":"Acme","total":"$5,200"}'

# Check document quality before delivery
officecli validate report.docx && officecli view report.docx issues --json

From Python or Node.js — install one of the thin resident-pipe SDKs (no per-call process spawn):

# Python — `pip install officecli-sdk`
import officecli
with officecli.create("deck.pptx") as doc:          # or officecli.open("deck.pptx")
    doc.send({"command": "add", "parent": "/", "type": "slide"})
    print(doc.send({"command": "get", "path": "/slide[1]"}))

// Node.js — `npm install @officecli/sdk`
const oc = require("@officecli/sdk");
const doc = await oc.create("deck.pptx");            // or oc.open("deck.pptx")
await doc.send({ command: "add", parent: "/", type: "slide" });
console.log(await doc.send({ command: "get", path: "/slide[1]" }));
await doc.close();

Both SDKs auto-provision the native CLI when missing (mirror-first, Windows-capable) and announce the install rather than doing it silently.

Or wrap subprocess directly, one-shot:

import json, subprocess
def cli(*args):
    return json.loads(subprocess.check_output(["officecli", *args, "--json"], text=True))
cli("create", "deck.pptx")

Documentation

The Wiki has detailed guides for every command, element type, and property:

• By format: Word | Excel | PowerPoint
• Workflows: End-to-end examples -- Word reports, Excel dashboards, PowerPoint decks, batch modifications, resident mode
• Runnable examples: examples/ -- copy-paste scripts (.sh/.py) for Word, Excel, and PowerPoint, with output files included
• Troubleshooting: Common errors and solutions
• AI agent guide: Decision tree for navigating the wiki

Build from Source

Requires .NET 10 SDK for compilation only. The output is a self-contained, native binary -- .NET is embedded in the binary and is not needed at runtime.

./build.sh

from https://github.com/iOfficeAI/OfficeCLI

下载windows版的程序：https://github.com/iOfficeAI/OfficeCLI/releases/download/v1.0.150/officecli-win-x64.exe

--------------------------------------

相关帖子：

https://briteming.blogspot.com/2026/08/onlyoffice-desktopeditors.html （这个程序不错，可以取代microsoft office和wps)

https://briteming.blogspot.com/2026/08/onlyofficepersonal.html