visionary-cli 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 PassingTraveller111
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# Visionary CLI
+
+Command line tools for publishing and managing Visionary content.
+
+## Local Global Install
+
+```bash
+npm link
+```
+
+After linking, run the CLI from any directory:
+
+```bash
+visionary --help
+visionary auth login --username <username> --password <password> --base-url <url>
+visionary draft create --title <title> --content-file <path> --summary <text> --tags <a,b>
+visionary draft publish --id <id> --confirm
+```
+
+The `visionary-cli` command is also available as an alias.
+
+## Configuration
+
+The CLI reads auth and target site values from these sources, in priority order:
+
+1. Command options such as `--base-url`, `--token`, and `--cookie`
+2. Environment variables: `VISIONARY_BASE_URL`, `VISIONARY_TOKEN`, `VISIONARY_COOKIE`
+3. Saved config at `~/.visionary-cli/config.json`
+4. Default service: `https://visionaryblog.cn`
+
+Run `visionary auth login ...` to save the token and base URL locally.

package/api.mjs

@@ -0,0 +1,182 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { homedir } from 'node:os';
+import { basename, join } from 'node:path';
+
+const DEFAULT_BASE_URLS = ['https://visionaryblog.cn'];
+const CONFIG_DIR = join(homedir(), '.visionary-cli');
+
+export const CONFIG_FILE = join(CONFIG_DIR, 'config.json');
+
+const endpoints = {
+  login: '/api/auth/login',
+  getUserInfo: '/api/users/me',
+};
+
+let resolvedBaseUrl;
+let storedConfig = {};
+
+export async function initializeConfig() {
+  storedConfig = await loadConfig();
+}
+
+export function getResolvedBaseUrl() {
+  return resolvedBaseUrl;
+}
+
+export async function request(path, options, init = {}) {
+  const cookie = getCookie(options);
+  const candidates = resolvedBaseUrl ? [resolvedBaseUrl] : getBaseUrlCandidates(options);
+  let lastError;
+  const hasJsonBody = typeof init.body === 'string';
+
+  for (const baseUrl of candidates) {
+    try {
+      const response = await fetch(`${baseUrl}${path}`, {
+        ...init,
+        headers: {
+          Accept: 'application/json',
+          Cookie: cookie,
+          ...(hasJsonBody ? { 'Content-Type': 'application/json' } : {}),
+          ...init.headers,
+        },
+      });
+
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : null;
+
+      if (!response.ok) {
+        lastError = new Error(`HTTP ${response.status}`);
+        lastError.details = data;
+        if (response.status === 404 && !resolvedBaseUrl) continue;
+        throw lastError;
+      }
+
+      resolvedBaseUrl = baseUrl;
+      return data;
+    } catch (error) {
+      lastError = error;
+      if (resolvedBaseUrl) break;
+    }
+  }
+
+  throw lastError;
+}
+
+export async function loginRequest(options, body) {
+  const candidates = getBaseUrlCandidates(options);
+  let lastError;
+
+  for (const baseUrl of candidates) {
+    try {
+      const response = await fetch(`${baseUrl}${endpoints.login}`, {
+        method: 'POST',
+        headers: {
+          Accept: 'application/json',
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(body),
+      });
+
+      const text = await response.text();
+      const data = text ? JSON.parse(text) : null;
+
+      if (!response.ok) {
+        lastError = new Error(data?.message || data?.msg || `HTTP ${response.status}`);
+        lastError.details = data;
+        if (response.status === 404) continue;
+        throw lastError;
+      }
+
+      const setCookie = response.headers.get('set-cookie') || '';
+      const token = parseTokenFromSetCookie(setCookie);
+      if (!token) {
+        throw new Error('Login succeeded but no token cookie was returned.');
+      }
+
+      resolvedBaseUrl = baseUrl;
+      return { data, token };
+    } catch (error) {
+      lastError = error;
+    }
+  }
+
+  throw lastError;
+}
+
+export async function saveAuthConfig(token) {
+  storedConfig = {
+    ...storedConfig,
+    baseUrl: resolvedBaseUrl,
+    token,
+  };
+  await saveConfig(storedConfig);
+}
+
+export async function getCurrentUser(options) {
+  const response = await request(endpoints.getUserInfo, options, { method: 'GET' });
+  if (response?.ok !== true) {
+    throw new Error('Failed to read current user info. Check token/cookie permissions.');
+  }
+  return response.data;
+}
+
+export async function uploadFileRequest(options, path, filePath) {
+  const buffer = await readFile(filePath);
+  const formData = new FormData();
+  formData.append('file', new Blob([buffer]), basename(filePath));
+
+  const response = await request(path, options, {
+    method: 'POST',
+    body: formData,
+  });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to upload file.');
+  }
+
+  return response.data;
+}
+
+function getBaseUrlCandidates(options) {
+  const configuredBaseUrl = options.baseUrl || process.env.VISIONARY_BASE_URL || storedConfig.baseUrl;
+  if (configuredBaseUrl) return [normalizeBaseUrl(configuredBaseUrl)];
+  return DEFAULT_BASE_URLS;
+}
+
+function normalizeBaseUrl(baseUrl) {
+  try {
+    return new URL(baseUrl).origin;
+  } catch {
+    return baseUrl.replace(/\/+$/, '');
+  }
+}
+
+function getCookie(options) {
+  const cookie = options.cookie || process.env.VISIONARY_COOKIE;
+  if (cookie) return cookie;
+
+  const token = options.token || process.env.VISIONARY_TOKEN || storedConfig.token;
+  if (token) return `token=${token}`;
+
+  throw new Error('Missing auth. Run auth login, or provide --token, --cookie, VISIONARY_TOKEN, or VISIONARY_COOKIE.');
+}
+
+async function loadConfig() {
+  try {
+    const configText = await readFile(CONFIG_FILE, 'utf8');
+    return JSON.parse(configText);
+  } catch (error) {
+    if (error.code === 'ENOENT') return {};
+    throw error;
+  }
+}
+
+async function saveConfig(config) {
+  await mkdir(CONFIG_DIR, { recursive: true, mode: 0o700 });
+  await writeFile(CONFIG_FILE, `${JSON.stringify(config, null, 2)}\n`, { mode: 0o600 });
+}
+
+function parseTokenFromSetCookie(setCookie) {
+  const match = setCookie.match(/(?:^|,\s*)token=([^;]+)/);
+  return match ? decodeURIComponent(match[1]) : '';
+}

package/article.mjs

@@ -0,0 +1,138 @@
+import { getCurrentUser, getResolvedBaseUrl, request, uploadFileRequest } from './api.mjs';
+import { buildQuery, output, parseIntegerOption, requireOption } from './shared.mjs';
+
+export async function handleArticleCommand(subcommand, options) {
+  if (subcommand === 'list') return listArticles(options);
+  if (subcommand === 'public-list') return listPublishedArticles(options);
+  if (subcommand === 'search') return searchArticles(options);
+  if (subcommand === 'get') return getArticle(options);
+  if (subcommand === 'delete') return deleteArticle(options);
+  if (subcommand === 'cover-upload') return uploadArticleCover(options);
+  if (subcommand === 'image-upload') return uploadArticleImage(options);
+  throw new Error(`Unknown article subcommand: ${subcommand}`);
+}
+
+async function readUserArticles(options, userId) {
+  const response = await request(`/api/users/${Number(userId)}/articles`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read user articles.');
+  }
+
+  return response.data;
+}
+
+async function readPublishedArticles(options) {
+  const pageNum = parseIntegerOption(options, 'pageNum', 0);
+  const pageSize = parseIntegerOption(options, 'pageSize', 8);
+  const sort = options.sort || 'new';
+  const response = await request(`/api/articles${buildQuery({ pageNum, pageSize, sort })}`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read published articles.');
+  }
+
+  return response.data;
+}
+
+async function searchArticlesRequest(options) {
+  const keyword = requireOption(options, 'keyword');
+  const pageNum = parseIntegerOption(options, 'pageNum', 0);
+  const pageSize = parseIntegerOption(options, 'pageSize', 8);
+  const response = await request(`/api/articles${buildQuery({ keyword, pageNum, pageSize })}`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to search articles.');
+  }
+
+  return response.data;
+}
+
+async function readArticle(options, id) {
+  const response = await request(`/api/articles/${Number(id)}`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read article.');
+  }
+
+  return response.data;
+}
+
+async function deleteArticleRequest(options, id) {
+  const response = await request(`/api/articles/${Number(id)}`, options, { method: 'DELETE' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to delete article.');
+  }
+
+  return response.data;
+}
+
+async function listArticles(options) {
+  const userId = options.userId || (await getCurrentUser(options)).id;
+  const limit = parseIntegerOption(options, 'limit', 0);
+  let articles = await readUserArticles(options, userId);
+
+  if (options.publishedOnly) {
+    articles = articles.filter((article) => article.is_published === 1);
+  }
+
+  if (limit > 0) {
+    articles = articles.slice(0, limit);
+  }
+
+  output({ success: true, action: 'article.list', userId: Number(userId), count: articles.length, articles });
+}
+
+async function listPublishedArticles(options) {
+  const data = await readPublishedArticles(options);
+  output({ success: true, action: 'article.public-list', ...data });
+}
+
+async function searchArticles(options) {
+  const data = await searchArticlesRequest(options);
+  output({ success: true, action: 'article.search', keyword: options.keyword, ...data });
+}
+
+async function getArticle(options) {
+  const id = requireOption(options, 'id');
+  const article = await readArticle(options, id);
+  output({
+    success: true,
+    action: 'article.get',
+    article,
+    articleUrl: `${getResolvedBaseUrl()}/reader/${id}`,
+  });
+}
+
+async function deleteArticle(options) {
+  if (!options.confirm) {
+    throw new Error('Deleting an article requires --confirm to avoid accidental removal.');
+  }
+
+  const id = requireOption(options, 'id');
+  const data = await deleteArticleRequest(options, id);
+  output({ success: true, action: 'article.delete', articleId: Number(id), data });
+}
+
+async function uploadArticleCover(options) {
+  const filePath = requireOption(options, 'file');
+  const data = await uploadFileRequest(options, '/api/articles/cover', filePath);
+  output({
+    success: true,
+    action: 'article.cover-upload',
+    cover: data?.Location ? `https://${data.Location}` : undefined,
+    data,
+  });
+}
+
+async function uploadArticleImage(options) {
+  const filePath = requireOption(options, 'file');
+  const data = await uploadFileRequest(options, '/api/articles/images', filePath);
+  output({
+    success: true,
+    action: 'article.image-upload',
+    image: data?.Location ? `https://${data.Location}` : undefined,
+    data,
+  });
+}

package/auth.mjs

@@ -0,0 +1,38 @@
+import { CONFIG_FILE, getResolvedBaseUrl, loginRequest, saveAuthConfig } from './api.mjs';
+import { output } from './shared.mjs';
+
+export async function handleAuthCommand(subcommand, options) {
+  if (subcommand === 'login') return login(options);
+  throw new Error(`Unknown auth subcommand: ${subcommand}`);
+}
+
+async function login(options) {
+  const username = options.username || process.env.VISIONARY_USERNAME;
+  const password = options.password || process.env.VISIONARY_PASSWORD;
+
+  if (!username) throw new Error('Missing required option --username or VISIONARY_USERNAME');
+  if (!password) throw new Error('Missing required option --password or VISIONARY_PASSWORD');
+
+  const { data, token } = await loginRequest(options, {
+    username,
+    password,
+    isRemember: Boolean(options.remember),
+  });
+
+  await saveAuthConfig(token);
+
+  output({
+    success: true,
+    action: 'auth.login',
+    baseUrl: getResolvedBaseUrl(),
+    configFile: CONFIG_FILE,
+    user: sanitizeUser(data?.data),
+  });
+}
+
+function sanitizeUser(user) {
+  if (!user) return undefined;
+  const safeUser = { ...user };
+  delete safeUser.password;
+  return safeUser;
+}

package/bin/visionary.mjs

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+import { run } from '../index.mjs';
+
+run();

package/column.mjs

@@ -0,0 +1,197 @@
+import { getCurrentUser, getResolvedBaseUrl, request, uploadFileRequest } from './api.mjs';
+import { output, parseIds, requireOption } from './shared.mjs';
+
+export async function handleColumnCommand(subcommand, options) {
+  if (subcommand === 'list') return listColumns(options);
+  if (subcommand === 'get') return getColumn(options);
+  if (subcommand === 'create') return createColumn(options);
+  if (subcommand === 'update') return updateColumn(options);
+  if (subcommand === 'delete') return deleteColumn(options);
+  if (subcommand === 'articles') return getColumnArticles(options);
+  if (subcommand === 'set-articles') return setColumnArticles(options);
+  if (subcommand === 'candidates') return getColumnCandidates(options);
+  if (subcommand === 'cover-upload') return uploadColumnCover(options);
+  throw new Error(`Unknown column subcommand: ${subcommand}`);
+}
+
+async function readColumns(options, userId) {
+  const response = await request(`/api/users/${Number(userId)}/columns`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read columns.');
+  }
+
+  return response.data;
+}
+
+async function readColumn(options, id) {
+  const response = await request(`/api/columns/${Number(id)}`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read column.');
+  }
+
+  return response.data;
+}
+
+async function saveColumn(options, column) {
+  const isNewColumn = column.column_id === undefined;
+  const response = await request(isNewColumn ? '/api/columns' : `/api/columns/${Number(column.column_id)}`, options, {
+    method: isNewColumn ? 'POST' : 'PATCH',
+    body: JSON.stringify(column),
+  });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to save column.');
+  }
+
+  return response.data;
+}
+
+async function deleteColumnRequest(options, id) {
+  const response = await request(`/api/columns/${Number(id)}`, options, { method: 'DELETE' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to delete column.');
+  }
+
+  return response.data;
+}
+
+async function readColumnArticles(options, id) {
+  const response = await request(`/api/columns/${Number(id)}/articles`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read column articles.');
+  }
+
+  return response.data;
+}
+
+async function updateColumnArticles(options, id, articleIds) {
+  const response = await request(`/api/columns/${Number(id)}/articles`, options, {
+    method: 'PUT',
+    body: JSON.stringify({ article_ids: articleIds }),
+  });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to update column articles.');
+  }
+
+  return response.data;
+}
+
+async function readColumnCandidates(options) {
+  const response = await request('/api/articles/column-candidates', options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read column candidate articles.');
+  }
+
+  return response.data;
+}
+
+async function listColumns(options) {
+  const userId = options.userId || (await getCurrentUser(options)).id;
+  const columns = await readColumns(options, userId);
+  output({ success: true, action: 'column.list', userId: Number(userId), columns });
+}
+
+async function getColumn(options) {
+  const id = requireOption(options, 'id');
+  const [column, articles] = await Promise.all([
+    readColumn(options, id),
+    readColumnArticles(options, id),
+  ]);
+
+  output({
+    success: true,
+    action: 'column.get',
+    column,
+    articles,
+    columnUrl: `${getResolvedBaseUrl()}/userCenter/Columns/${id}`,
+    manageUrl: `${getResolvedBaseUrl()}/creator/content/columns/manage/${id}`,
+  });
+}
+
+async function createColumn(options) {
+  const name = requireOption(options, 'name');
+  const description = requireOption(options, 'description');
+
+  const data = await saveColumn(options, {
+    column_name: name,
+    description,
+    ...(options.cover ? { cover_image: options.cover } : {}),
+  });
+
+  const columnId = data?.insertId;
+  output({
+    success: true,
+    action: 'column.create',
+    columnId,
+    columnUrl: columnId ? `${getResolvedBaseUrl()}/userCenter/Columns/${columnId}` : undefined,
+    manageUrl: columnId ? `${getResolvedBaseUrl()}/creator/content/columns/manage/${columnId}` : undefined,
+    data,
+  });
+}
+
+async function updateColumn(options) {
+  const id = requireOption(options, 'id');
+  const existingColumn = await readColumn(options, id);
+
+  const data = await saveColumn(options, {
+    column_id: Number(id),
+    column_name: options.name ?? existingColumn.column_name ?? '',
+    description: options.description ?? existingColumn.description ?? '',
+    cover_image: options.cover ?? existingColumn.cover_image ?? '',
+  });
+
+  output({
+    success: true,
+    action: 'column.update',
+    columnId: Number(id),
+    columnUrl: `${getResolvedBaseUrl()}/userCenter/Columns/${id}`,
+    manageUrl: `${getResolvedBaseUrl()}/creator/content/columns/manage/${id}`,
+    data,
+  });
+}
+
+async function deleteColumn(options) {
+  if (!options.confirm) {
+    throw new Error('Deleting a column requires --confirm to avoid accidental removal.');
+  }
+
+  const id = requireOption(options, 'id');
+  const data = await deleteColumnRequest(options, id);
+  output({ success: true, action: 'column.delete', columnId: Number(id), data });
+}
+
+async function getColumnArticles(options) {
+  const id = requireOption(options, 'id');
+  const articles = await readColumnArticles(options, id);
+  output({ success: true, action: 'column.articles', columnId: Number(id), articles });
+}
+
+async function setColumnArticles(options) {
+  const id = requireOption(options, 'id');
+  if (options.articleIds === undefined) throw new Error('Missing required option --article-ids');
+  const articleIds = parseIds(options.articleIds);
+  const data = await updateColumnArticles(options, id, articleIds);
+  output({ success: true, action: 'column.set-articles', columnId: Number(id), articleIds, data });
+}
+
+async function getColumnCandidates(options) {
+  const articles = await readColumnCandidates(options);
+  output({ success: true, action: 'column.candidates', articles });
+}
+
+async function uploadColumnCover(options) {
+  const filePath = requireOption(options, 'file');
+  const data = await uploadFileRequest(options, '/api/columns/cover', filePath);
+  output({
+    success: true,
+    action: 'column.cover-upload',
+    cover: data?.Location ? `https://${data.Location}` : undefined,
+    data,
+  });
+}

package/draft.mjs

@@ -0,0 +1,185 @@
+import { readFile } from 'node:fs/promises';
+import { getCurrentUser, getResolvedBaseUrl, request } from './api.mjs';
+import { normalizeTags, output, parseTags, requireOption, stripLeadingH1 } from './shared.mjs';
+
+export async function handleDraftCommand(subcommand, options) {
+  if (subcommand === 'create') return createDraft(options);
+  if (subcommand === 'get') return getDraft(options);
+  if (subcommand === 'update') return updateDraft(options);
+  if (subcommand === 'publish') return publishDraft(options);
+  throw new Error(`Unknown draft subcommand: ${subcommand}`);
+}
+
+async function readDraft(options, id) {
+  const response = await request(`/api/drafts/${Number(id)}`, options, { method: 'GET' });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to read draft.');
+  }
+
+  return response.data;
+}
+
+async function saveDraft(options, draft) {
+  const isNewDraft = draft.draftId === 'new';
+  const response = await request(isNewDraft ? '/api/drafts' : `/api/drafts/${Number(draft.draftId)}`, options, {
+    method: isNewDraft ? 'POST' : 'PATCH',
+    body: JSON.stringify(draft),
+  });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to save draft.');
+  }
+
+  return response.data;
+}
+
+async function publishDraftRequest(options, draftId) {
+  const response = await request(`/api/drafts/${Number(draftId)}/publish`, options, {
+    method: 'POST',
+  });
+
+  if (response?.ok !== true) {
+    throw new Error(response?.error?.message || 'Failed to publish draft.');
+  }
+
+  return response.data;
+}
+
+async function loadContent(options, existingContent = '') {
+  if (options.content !== undefined && options.contentFile) {
+    throw new Error('Use either --content or --content-file, not both.');
+  }
+
+  if (options.content !== undefined) {
+    return options.keepTitle ? options.content : stripLeadingH1(options.content);
+  }
+
+  if (!options.contentFile) return existingContent;
+  const content = await readFile(options.contentFile, 'utf8');
+  return options.keepTitle ? content : stripLeadingH1(content);
+}
+
+function requireDraftContent(options) {
+  if (options.content !== undefined || options.contentFile) return;
+  throw new Error('Missing required option --content or --content-file');
+}
+
+async function createDraft(options) {
+  const title = requireOption(options, 'title');
+  requireDraftContent(options);
+
+  const [user, content] = await Promise.all([
+    getCurrentUser(options),
+    loadContent(options),
+  ]);
+
+  const data = await saveDraft(options, {
+    draftId: 'new',
+    title,
+    content,
+    summary: options.summary || '',
+    tags: parseTags(options.tags),
+    author_id: user.id,
+    author_nickname: user.nick_name,
+    cover: options.cover || '',
+  });
+
+  const draftId = data?.insertId;
+  const urls = buildDraftUrls({ draftId });
+  output({
+    success: true,
+    action: 'draft.create',
+    draftId,
+    draftUrl: urls.draftUrl,
+    data,
+  });
+}
+
+async function getDraft(options) {
+  const id = requireOption(options, 'id');
+  const draft = await readDraft(options, id);
+  const urls = buildDraftUrls({ draftId: id });
+  output({
+    success: true,
+    action: 'draft.get',
+    draftId: Number(id),
+    draftUrl: urls.draftUrl,
+    draft,
+  });
+}
+
+async function updateDraft(options) {
+  const id = requireOption(options, 'id');
+  const existingDraft = await readDraft(options, id);
+  const content = await loadContent(options, existingDraft.content || '');
+
+  const data = await saveDraft(options, {
+    draftId: Number(id),
+    title: options.title ?? existingDraft.title ?? '',
+    content,
+    summary: options.summary ?? existingDraft.summary ?? '',
+    tags: parseTags(options.tags, existingDraft.tags),
+    author_id: existingDraft.author_id,
+    author_nickname: existingDraft.author_nickname,
+    cover: options.cover ?? existingDraft.cover ?? '',
+  });
+
+  const urls = buildDraftUrls({ draftId: id });
+  output({
+    success: true,
+    action: 'draft.update',
+    draftId: Number(id),
+    draftUrl: urls.draftUrl,
+    data,
+  });
+}
+
+async function publishDraft(options) {
+  if (!options.confirm) {
+    throw new Error('Publishing requires --confirm to avoid accidental release.');
+  }
+
+  const id = requireOption(options, 'id');
+  const draft = await readDraft(options, id);
+  validatePublishableDraft(draft);
+
+  const data = await publishDraftRequest(options, id);
+  const articleId = data?.article_id;
+  const reviewId = data?.review_id;
+  const urls = buildDraftUrls({ draftId: data?.draft_id ?? id, reviewId, articleId });
+
+  output({
+    success: true,
+    action: 'draft.publish',
+    draftId: data?.draft_id ?? Number(id),
+    reviewId,
+    articleId,
+    draftUrl: urls.draftUrl,
+    reviewUrl: urls.reviewUrl,
+    articleUrl: urls.articleUrl,
+    note: 'The backend marks the article published after its async review step completes.',
+    data,
+  });
+}
+
+function buildDraftUrls({ draftId, reviewId, articleId }) {
+  const baseUrl = getResolvedBaseUrl();
+  return {
+    draftUrl: draftId ? `${baseUrl}/editor/draft/v2/${draftId}` : undefined,
+    reviewUrl: reviewId ? `${baseUrl}/reader/review/${reviewId}` : undefined,
+    articleUrl: articleId ? `${baseUrl}/reader/${articleId}` : undefined,
+  };
+}
+
+function validatePublishableDraft(draft) {
+  const missing = [];
+  if (!draft.title) missing.push('title');
+  if (!draft.content) missing.push('content');
+  if (!draft.summary) missing.push('summary');
+  if (!normalizeTags(draft.tags).length) missing.push('tags');
+
+  if (missing.length) {
+    throw new Error(`Draft is not publishable. Missing: ${missing.join(', ')}.`);
+  }
+}

package/index.mjs

@@ -0,0 +1,30 @@
+import process from 'node:process';
+import { handleArticleCommand } from './article.mjs';
+import { handleAuthCommand } from './auth.mjs';
+import { handleColumnCommand } from './column.mjs';
+import { handleDraftCommand } from './draft.mjs';
+import { initializeConfig } from './api.mjs';
+import { fail, parseArgs, printUsage } from './shared.mjs';
+
+export async function main(argv = process.argv.slice(2)) {
+  await initializeConfig();
+  const { command, subcommand, options } = parseArgs(argv);
+
+  if (options.help || command === '--help' || !command) {
+    printUsage();
+    return;
+  }
+
+  if (command === 'auth') return handleAuthCommand(subcommand, options);
+  if (command === 'draft') return handleDraftCommand(subcommand, options);
+  if (command === 'article') return handleArticleCommand(subcommand, options);
+  if (command === 'column') return handleColumnCommand(subcommand, options);
+
+  throw new Error(`Unknown command: ${command}`);
+}
+
+export function run() {
+  main().catch((error) => {
+    fail(error.message, error.details);
+  });
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "visionary-cli",
+  "version": "0.1.0",
+  "description": "A Visionary CLI for AI-assisted writing workflows, content publishing, and article management.",
+  "type": "module",
+  "bin": {
+    "visionary": "./bin/visionary.mjs",
+    "visionary-cli": "./bin/visionary.mjs"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/PassingTraveller111/visionary-cli.git"
+  },
+  "homepage": "https://github.com/PassingTraveller111/visionary-cli#readme",
+  "bugs": {
+    "url": "https://github.com/PassingTraveller111/visionary-cli/issues"
+  },
+  "keywords": [
+    "visionary",
+    "cli",
+    "markdown",
+    "publishing",
+    "ai-writing"
+  ],
+  "author": "PassingTraveller111",
+  "license": "MIT",
+  "files": [
+    "bin",
+    "*.mjs",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/shared.mjs

@@ -0,0 +1,151 @@
+export function printUsage() {
+  console.log(`Usage:
+  visionary auth login --username <username> --password <password> [--base-url <url>] [--remember]
+  visionary draft create --title <title> (--content <markdown> | --content-file <path>) [--summary <text>] [--tags <a,b>] [--cover <url>] [--keep-title]
+  visionary draft get --id <id>
+  visionary draft update --id <id> [--title <title>] [--content <markdown> | --content-file <path>] [--summary <text>] [--tags <a,b>] [--cover <url>] [--keep-title]
+  visionary draft publish --id <id> --confirm
+  visionary article list [--user-id <id>] [--limit <n>] [--published-only]
+  visionary article public-list [--page-num <n>] [--page-size <n>] [--sort new|hot]
+  visionary article search --keyword <text> [--page-num <n>] [--page-size <n>]
+  visionary article get --id <id>
+  visionary article delete --id <id> --confirm
+  visionary article cover-upload --file <path>
+  visionary article image-upload --file <path>
+  visionary column list [--user-id <id>]
+  visionary column get --id <id>
+  visionary column create --name <name> --description <text> [--cover <url>]
+  visionary column update --id <id> [--name <name>] [--description <text>] [--cover <url>]
+  visionary column delete --id <id> --confirm
+  visionary column articles --id <id>
+  visionary column set-articles --id <id> --article-ids <id,id>
+  visionary column candidates
+  visionary column cover-upload --file <path>
+
+Options:
+  --base-url <url>     Visionary site URL. Defaults to VISIONARY_BASE_URL, saved config, then https://visionaryblog.cn.
+  --token <token>      Auth token value. Defaults to VISIONARY_TOKEN, then saved config.
+  --cookie <cookie>    Full Cookie header. Defaults to VISIONARY_COOKIE.
+  --remember           Ask login API to issue a longer-lived token.
+  --confirm            Required for commands that publish content.
+  --keep-title         Keep a leading H1 from --content/--content-file. By default, leading H1 is stripped before upload.
+  --json               Kept for agent compatibility. Output is always JSON.
+  --help               Show this help.
+`);
+}
+
+export function parseArgs(argv) {
+  const args = [...argv];
+  const command = args.shift();
+  const subcommand = args.shift();
+  const options = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (!arg.startsWith('--')) {
+      throw new Error(`Unexpected argument: ${arg}`);
+    }
+
+    const key = arg.slice(2);
+    if (key === 'json' || key === 'help' || key === 'remember' || key === 'confirm' || key === 'keep-title' || key === 'published-only') {
+      options[toCamelCase(key)] = true;
+      continue;
+    }
+
+    const value = args[index + 1];
+    if (value === undefined || value.startsWith('--')) {
+      throw new Error(`Missing value for --${key}`);
+    }
+
+    options[toCamelCase(key)] = value;
+    index += 1;
+  }
+
+  return { command, subcommand, options };
+}
+
+export function output(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+
+export function fail(message, details) {
+  output({ success: false, error: message, details });
+  process.exitCode = 1;
+}
+
+export function stripLeadingH1(content) {
+  return content
+    .replace(/^\uFEFF?\s*#\s+[^\n]*(?:\n+|$)/, '')
+    .replace(/^\uFEFF?\s*<h1(?:\s+[^>]*)?>[\s\S]*?<\/h1>\s*/i, '');
+}
+
+export function parseTags(value, fallback = []) {
+  if (value === undefined) return normalizeTags(fallback);
+
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+
+  if (trimmed.startsWith('[')) {
+    const parsed = JSON.parse(trimmed);
+    return normalizeTags(parsed);
+  }
+
+  return trimmed.split(',').map((tag) => tag.trim()).filter(Boolean);
+}
+
+export function parseIds(value) {
+  if (value === undefined) return [];
+
+  const trimmed = value.trim();
+  if (!trimmed) return [];
+
+  if (trimmed.startsWith('[')) {
+    const parsed = JSON.parse(trimmed);
+    if (!Array.isArray(parsed)) throw new Error('--article-ids JSON value must be an array.');
+    return parsed.map((id) => String(id).trim()).filter(Boolean);
+  }
+
+  return trimmed.split(',').map((id) => id.trim()).filter(Boolean);
+}
+
+export function normalizeTags(value) {
+  if (Array.isArray(value)) return value.map(String);
+  if (typeof value === 'string') {
+    try {
+      const parsed = JSON.parse(value);
+      if (Array.isArray(parsed)) return parsed.map(String);
+    } catch {
+      return value.split(',').map((tag) => tag.trim()).filter(Boolean);
+    }
+  }
+  return [];
+}
+
+export function requireOption(options, key) {
+  if (!options[key]) throw new Error(`Missing required option --${formatOptionName(key)}`);
+  return options[key];
+}
+
+export function parseIntegerOption(options, key, fallback) {
+  if (options[key] === undefined) return fallback;
+  const value = Number(options[key]);
+  if (!Number.isInteger(value)) throw new Error(`Invalid --${formatOptionName(key)} value.`);
+  return value;
+}
+
+export function buildQuery(params) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== undefined && value !== '') query.set(key, String(value));
+  }
+  const queryString = query.toString();
+  return queryString ? `?${queryString}` : '';
+}
+
+function toCamelCase(value) {
+  return value.replace(/-([a-z])/g, (_, char) => char.toUpperCase());
+}
+
+function formatOptionName(key) {
+  return key.replace(/[A-Z]/g, (char) => `-${char.toLowerCase()}`);
+}