DEV Community: SimonLi

Learning Vim Swiftly: A Quick Start for Servers

SimonLi — Tue, 22 Sep 2026 12:55:22 +0000

When you SSH into a remote server, there is often no GUI editor available, but Vim is almost always installed. This guide covers the minimum you need to edit files confidently on a server.

1. Modes: The Core Idea

Vim is a modal editor. When you open a file, you start in Normal mode, where keys are commands rather than text. This is the main reason beginners feel lost.

Mode	How to enter	Purpose
Normal	`Esc`	Move, delete, copy, paste
Insert	`i` (and others, see §4)	Type text
Command-line	`:` in Normal mode	Save, quit, search & replace
Visual	`v` / `V` / `Ctrl+v`	Select text

Tip: If you ever get lost, press Esc a few times to return to Normal mode.

2. Survival Kit

Suppose you want to edit a file named train.py:

vim train.py    open the file (creates it if it doesn't exist)
i               enter Insert mode and start typing
Esc             back to Normal mode
:w              save
:q              quit
:wq  or  :x     save and quit
:q!             quit WITHOUT saving (use it when you mess up)

With just these, you can already edit config files and scripts on a server.

3. Moving the Cursor (Normal Mode)

h j k l          left / down / up / right (arrow keys also work)
w / b            next word / previous word
0 / $            start / end of line
gg / G           start / end of file
:42  or  42G     jump to line 42
Ctrl+d / Ctrl+u  scroll down / up half a page
%                jump between matching brackets ( ) [ ] { }

4. Entering Insert Mode

i   insert before the cursor
a   insert after the cursor
I   insert at the start of the line
A   insert at the end of the line (very common)
o   open a new line below
O   open a new line above

5. Editing

x        delete one character
dd       delete (cut) the whole line
3dd      delete 3 lines
dw       delete a word
D        delete to end of line
yy       copy (yank) the whole line
p / P    paste below / above
u        undo
Ctrl+r   redo
.        repeat the last change (extremely useful)

The Grammar of Vim

Vim commands compose: operator + motion. d means delete and w means one word, so dw deletes a word. Once you see this pattern, you no longer need to memorize every command.

Operator	Meaning
`d`	delete
`y`	yank (copy)
`c`	change (delete, then enter Insert mode)

A few useful combinations:

y$       copy to end of line
d0       delete to start of line
dG       delete to end of file
ciw      change the word under the cursor
ci"      change everything inside the quotes
ci(      change everything inside the parentheses
dt)      delete up to (but not including) the next )

6. Visual Mode

v        select by character
V        select by line
Ctrl+v   select a block (columns)

After selecting, press d to delete, y to copy, or > / < to indent.

Comment out multiple lines:

Move to the first line, press Ctrl+v, then press j to extend the selection down.
Press I (capital i) and type #.
Press Esc. Every selected line now starts with #.

7. Search and Replace

/lr                 search forward for "lr"
n / N               next / previous match
*                   search for the word under the cursor
:%s/old/new/g       replace every "old" with "new" in the file
:%s/old/new/gc      replace with confirmation for each match
:noh                clear search highlighting

8. Server Tips

Read-only viewing

view log.txt
# or
vim -R log.txt

This prevents accidental edits. For large logs, press G to jump straight to the end.

Multiple files

:vsp other.py    split vertically (side by side)
:sp other.py     split horizontally
Ctrl+w w         switch between windows

Pasting code without broken indentation

When you paste code into Vim through a terminal, auto-indent can stack up and ruin the formatting. Turn on paste mode first:

:set paste      before pasting
:set nopaste    after pasting

Forgot `sudo`?

If you edited a system file and get a permission error when saving, you don't need to start over:

:w !sudo tee %

Common pitfalls

Screen frozen? You probably pressed Ctrl+s out of habit, which pauses terminal output. Press Ctrl+q to resume.
"Found a swap file" warning? Vim creates a .swp file while editing. This warning appears if Vim crashed, your SSH connection dropped, or the file is open elsewhere. Press R to recover, or D to delete the old swap file if you're sure it's stale.
Can't copy text to your local machine after set mouse=a? Hold Shift while dragging to use the terminal's own selection instead.

9. Configuration: `~/.vimrc`

~/.vimrc is Vim's config file. Vim reads it at every startup, so settings you put here apply automatically. The default config on most servers is minimal, so start with these:

syntax on           " syntax highlighting
set number          " show line numbers
set tabstop=4       " a Tab displays as 4 spaces wide
set shiftwidth=4    " indent by 4 spaces
set expandtab       " insert spaces instead of Tab (essential for Python)
set autoindent      " keep indentation on new lines
set hlsearch        " highlight all search matches
set incsearch       " search as you type
set mouse=a         " enable the mouse

Text after " is a comment and is ignored by Vim.

To create the file:

vim ~/.vimrc
# press i, paste the config, press Esc, then type :wq

10. What's Next

Run vimtutor on your server. It's an interactive tutorial bundled with Vim that takes about 30 minutes, and it's more effective than any article, including this one.
In the first week, stick to sections 2 through 5 and try not to use the arrow keys or mouse.
After that, deliberately practice composed commands like ciw, dt), and ..

For heavy development work, consider VS Code with Remote-SSH, and keep Vim for quick edits and log inspection. The two work well together.

everything about jev

SimonLi — Mon, 21 Sep 2026 11:08:38 +0000

qingshungLI / everything-about-jev

tell you everything about jev,TypeSafe AI's System One model for typed decisions.

Everything about Jev

简体中文 · English

这里整理了 Jev 的使用方法、示例代码、社区项目和讨论。如果你刚听说这个模型，可以先读下面的介绍，再选一个 demo 跑起来。

快速开始 · 示例 · 社区讨论 · 项目目录

Jev 是什么

Jev 是 TypeSafe AI 的决策模型。你给它一段文本或业务状态，再定义问题和可选答案，它会返回选择、评分和概率。

比如收到一条“我的订阅扣了两次钱”的消息，你可以让 Jev 判断该交给哪个团队、是否需要人工处理，以及紧急程度。它返回的字段可以直接用于程序里的条件分支。

类型	用法	返回值
Choice	从“账单、技术、其他”中选择	选项、confidence、各选项概率
Noul	判断是否需要人工处理	“是”的概率
Score	按给定量表评估紧急程度	评分和概率分布，评分可能为小数

Jev 适合分类、路由、筛选和有限动作选择。需要写回复时，可以接生成模型；需要查最新信息时，由应用先检索，再把结果传给 Jev。confidence 和获选项概率是不同字段，接入时要注意区分。

系统说明介绍了这三类问题、模型边界，以及如何在应用里处理不确定的结果。

快速开始

需要 Python 3.10+。下面使用 jevai.org 社区 API；使用 TypeSafe 官方密钥的读者请看官方 SDK 示例。

git clone https://github.com/qingshungLI/everything-about-jev.git
cd everything-about-jev
python -m pip install -r requirements.txt

在根目录创建 .env：

JEVAI_API_KEY=你的社区服务密钥

运行：

python demos/python/quickstart.py

默认示例把“把页面变暗一点，晚上看太刺眼了”匹配到 dark_mode。它只返回动作名称，不操作浏览器。密钥文件已加入 .gitignore。

也可以用 TypeScript（Node.js 20+）：

npm ci
npm run demo:community

遇到限流或密钥问题，参见接入说明。社区 API 和官方 API 使用各自的密钥，具体区别见供应方对照。

示例

示例	内容	Python 参数
命令面板	根据一句话选择深色模式、导出或帮助	`--case palette`
工单分类	同时判断队列、人工需求和紧急度	`--case ticket`
资料核对	判断提供的资料是否支持一个说法	`--case research`
模型路由	从给定候选中选择适合任务的模型	`--case model-route`
工具检查	检查工具调用是否符合操作规则	`--case tool-guard`
完成检查	根据已完成工作和缺失项判断任务状态	`--case completion`

例如：

python demos/python/quickstart.py --case model-route

更多语言和演示入口：

Python、TypeScript、Node.js、Bash / curl。
浏览器演示：离线模拟，适合讲解交互流程。
…

View on GitHub

Recently, many people have been discussing Jev, a product launched by TypeSafe AI. Rather than writing articles or chatting with you, Jev makes decisions, classifications, and evaluations based on the information provided—for example, determining who a ticket should be assigned to or which tool should be called next.

I’ve put together a bilingual Chinese–English repository covering Jev’s core principles, integration methods, community projects, and the debates surrounding it. It also includes runnable examples in Python, TypeScript, Node.js, and more, so you can try it out directly.

If you want to understand what Jev can do and where it fits best, this is a good place to start.

How to Fix `already has an active writer` in Codex CLI

SimonLi — Mon, 21 Sep 2026 07:34:42 +0000

Fixing `already has an active writer` When Resuming a Codex CLI Session

When restoring a historical session in Codex CLI, you may see:

thread/resume failed during TUI bootstrap:
thread <THREAD_ID> already has an active writer (code -32600)

This guide provides a direct troubleshooting flow:

Install strace.
Identify the suspicious process associated with a specific JSONL session.
If individual diagnosis is unnecessary, clean up all leftover codex resume --all processes.

Important: Do not delete the session .jsonl file as a first response. The error usually means another process still owns the thread writer, not that the session file itself is corrupted.

1. Cause: a single-writer lock per thread

The already has an active writer error is not necessarily caused directly by a disconnected SSH session or a closed terminal. The underlying issue is that Codex enforces a single-writer constraint for each thread.

Codex continuously appends events to a session rollout .jsonl file. To prevent multiple processes from writing to the same thread at the same time—which could cause out-of-order events, duplicated entries, or inconsistent session history—Codex maintains writer ownership or a writer lock for each thread.

A new thread/resume request must obtain that writer lock before it can continue. Therefore, the error means:

The current resume request detected that writer ownership for this thread still belongs to another Codex instance or background writer task, so it refused to start a second writer.

2. Install `strace` on Linux

strace can help determine whether a process is accessing the target session file or making file-lock-related system calls.

First, identify your Linux distribution:

cat /etc/os-release

Install strace based on the distribution:

# Debian / Ubuntu
apt-get update && apt-get install -y strace

# Alpine
apk add --no-cache strace

# CentOS / RHEL / Rocky Linux / AlmaLinux
dnf install -y strace

# Older RHEL/CentOS systems
yum install -y strace

Verify the installation:

strace -V

3. Find the process for a specific JSONL session

Assume the error includes this session file:

/dfs/data/.codex-data/sessions/2026/09/21/rollout-2026-09-21T10-27-46-01a0c1ca-74cd-7d21-bd7b-1de7e03f7f96.jsonl

The thread ID that can be used for matching is:

01a0c1ca-74cd-7d21-bd7b-1de7e03f7f96

3.1 List all suspicious Codex PIDs

First, list all currently running Codex processes:

ps auxww | grep '[c]odex'

If the issue is likely caused by a bulk-resume task, narrow the list to:

ps auxww | grep '[c]odex resume --all'

The second column in the output is the PID. For example:

root  100621  ...  codex resume --all --include-non-interactive

In this example, 100621 is the PID.

3.2 Trace one PID with `strace`

Replace <PID> with the real process ID, for example 100621:

strace -f -tt -s 256 -p 100621 \
  -e trace=%file,flock,fcntl,read,write \
  2>&1 | tee /tmp/codex-100621.strace

Option	Purpose
`-p 100621`	Attaches to an existing process
`-f`	Also traces child processes and threads
`-tt`	Prints precise timestamps
`-s 256`	Prints up to 256 characters, avoiding truncated paths
`-e trace=%file,flock,fcntl,read,write`	Limits output to file access, locks, reads, and writes
`tee`	Writes output to both the terminal and a log file

Keep strace running. In another terminal, try codex resume again to trigger activity. Observe the output for a few seconds, then press Ctrl+C to stop strace.

Pressing Ctrl+C stops only strace; it does not terminate the Codex process being traced.

Search whether the PID accessed the target JSONL file or processed a lock:

grep -Ei '01a0c1ca-74cd-7d21-bd7b-1de7e03f7f96|writer|lock|\.jsonl' \
  /tmp/codex-100621.strace

If the output contains the complete target .jsonl path, or lock-related calls such as flock, fcntl, or F_SETLK, that PID is actively handling the session and should be treated as a priority investigation target.

3.3 Check every `resume --all` PID in bulk

If you have several suspicious processes, briefly trace each codex resume --all process and search for the target thread ID:

THREAD_ID='01a0c1ca-74cd-7d21-bd7b-1de7e03f7f96'

for pid in $(ps auxww | grep '[c]odex resume --all' | awk '{print $2}'); do
  echo "Checking PID: $pid"

  strace -f -tt -s 256 -p "$pid" \
    -e trace=%file,flock,fcntl \
    -o "/tmp/codex-$pid.strace" &

  trace_pid=$!
  sleep 3
  kill "$trace_pid" 2>/dev/null || true

  if grep -Eqi "$THREAD_ID|writer|lock|\.jsonl" "/tmp/codex-$pid.strace"; then
    echo "Possible match: PID $pid"
    grep -Ei "$THREAD_ID|writer|lock|\.jsonl" \
      "/tmp/codex-$pid.strace" | tail -n 20
  fi
done

A process that does not make a filesystem call during the three-second tracing window is not necessarily unrelated to the target thread. It may simply be idle or waiting. This script is intended to reduce the search space, not replace judgment about the process state and workload.

4. Terminate the process associated with one JSONL session

After confirming that a PID is not performing valid work and that it accesses or owns the target thread, inspect its full details first:

ps -fp <PID>

Try a graceful termination first:

kill <PID>

Wait three seconds and confirm whether it has exited:

sleep 3
ps -p <PID> -o pid,stat,etime,cmd

If it still exists, use a forced termination:

kill -9 <PID>

A plain kill sends SIGTERM, allowing the process an opportunity to release resources and run shutdown cleanup. kill -9 sends SIGKILL, which cannot be caught or handled; the process stops immediately and cannot perform cleanup. Use kill -9 only for a stuck process after you have confirmed that it is safe to terminate.

5. Terminate all `codex resume --all` processes

If you have confirmed that all codex resume --all --include-non-interactive processes are stale and no longer have business value, you can clean them up together.

5.1 Preview the processes first

ps auxww | grep '[c]odex resume --all'

Carefully check the START, TIME, TTY, and COMMAND columns. Do not terminate a session that was started recently and is still performing real work.

5.2 Send `SIGTERM` first

ps auxww | grep '[c]odex resume --all' | awk '{print $2}' | xargs -r kill

Wait a few seconds and check again:

sleep 3
ps auxww | grep '[c]odex resume --all'

5.3 Use `SIGKILL` only for surviving processes

ps auxww | grep '[c]odex resume --all' | awk '{print $2}' | xargs -r kill -9

The following script can be saved as kill_codex_resume_all.sh. It displays the target processes and asks for confirmation before sending SIGTERM. Passing -9 sends SIGKILL instead.

#!/usr/bin/env bash

PATTERN='[c]odex resume --all'
SIGNAL='TERM'

[ "${1:-}" = '-9' ] && SIGNAL='KILL'

PIDS=$(ps auxww | grep "$PATTERN" | awk '{print $2}')

if [ -z "$PIDS" ]; then
  echo 'No codex resume --all processes found'
  exit 0
fi

ps auxww | grep "$PATTERN"

printf '\nSend SIG%s to the PIDs above? [y/N] ' "$SIGNAL"
read -r answer

case "$answer" in
  y|Y) ;;
  *) echo 'Cancelled'; exit 0 ;;
esac

for pid in $PIDS; do
  kill -s "$SIGNAL" "$pid" && echo "Sent SIG$SIGNAL to PID: $pid"
done

Make the script executable and run it:

chmod +x kill_codex_resume_all.sh

# Default: send SIGTERM
./kill_codex_resume_all.sh

# Use SIGKILL only if normal termination did not work
./kill_codex_resume_all.sh -9

6. Resume the session again

After the stale writer process has been cleaned up, retry:

codex resume

If already has an active writer still appears, do not delete the session .jsonl file. At that point, one of the following is more likely:

The writer is still active on another machine, container, or Codex client.
Internal writer state on shared storage was not released normally.
Your current Codex version has a writer-ownership or app-server issue.

As a temporary workaround, start a new session without resume:

codex

Then investigate Codex instances in other environments, confirm the shared-storage path, and check the installed Codex version.