shipwatch 0.1.0

package/src/task-list.js

@@ -0,0 +1,157 @@
+/** Terminal task list renderer: fit columns to available cells and fall back to stacked fields.
+ * Exports formatTaskList; uses Intl grapheme segmentation and Node control-sequence stripping.
+ */
+import { stripVTControlCharacters } from 'node:util';
+import { colorLevel, toneCode, tint, gradient, stateTone, stateMark } from './terminal.js';
+
+const fields = ['ID', '名称', '状态', '自动部署', '自动次数', '启动时间'];
+const segments = new Intl.Segmenter(undefined, { granularity: 'grapheme' });
+
+/** Prevent filenames and error-state labels from adding terminal controls or extra rows. */
+function clean(value) {
+  return stripVTControlCharacters(String(value ?? '-')).replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, ' ');
+}
+
+/** Count terminal cells, keeping combining marks and emoji sequences attached to their base. */
+function cells(grapheme) {
+  if (/\p{Extended_Pictographic}|\p{Regional_Indicator}/u.test(grapheme)) return 2;
+  const visible = grapheme.replace(/[\p{Mark}\p{Format}]/gu, '');
+  if (!visible) return 0;
+  const code = visible.codePointAt(0);
+  return (code >= 0x1100 && (code <= 0x115f || code === 0x2329 || code === 0x232a ||
+    (code >= 0x2e80 && code <= 0xa4cf && code !== 0x303f) || (code >= 0xac00 && code <= 0xd7a3) ||
+    (code >= 0xf900 && code <= 0xfaff) || (code >= 0xfe10 && code <= 0xfe19) ||
+    (code >= 0xfe30 && code <= 0xfe6f) || (code >= 0xff00 && code <= 0xff60) ||
+    (code >= 0xffe0 && code <= 0xffe6) || (code >= 0x20000 && code <= 0x3fffd))) ? 2 : 1;
+}
+
+const graphemes = (value) => [...segments.segment(value)].map((item) => item.segment);
+const width = (value) => graphemes(value).reduce((total, item) => total + cells(item), 0);
+
+/** Take complete graphemes from one end without splitting CJK/emoji into partial cells. */
+function take(value, available, fromEnd = false) {
+  const parts = graphemes(value);
+  if (fromEnd) parts.reverse();
+  const result = [];
+  let used = 0;
+  for (const part of parts) {
+    const size = cells(part);
+    if (used + size > available) break;
+    result.push(part); used += size;
+  }
+  return (fromEnd ? result.reverse() : result).join('');
+}
+
+/** Retain both the directory root and final component when a path cannot fit its column. */
+function truncate(value, available, middle = false) {
+  if (width(value) <= available) return value;
+  if (!middle) return take(value, available - 1) + '…';
+  const prefix = Math.floor((available - 1) / 2);
+  return take(value, prefix) + '…' + take(value, available - prefix - 1, true);
+}
+
+/** Stacked records preserve fields on terminals too narrow even for the table headings. */
+function wrap(value, available) {
+  const lines = [];
+  let line = ''; let used = 0;
+  for (const part of graphemes(value)) {
+    const size = cells(part);
+    if (used + size > available && line) { lines.push(line); line = ''; used = 0; }
+    if (size > available) { lines.push('…'); continue; }
+    line += part; used += size;
+  }
+  if (line) lines.push(line);
+  return lines;
+}
+
+/** Shared clipping for dynamic terminal frames; measure Unicode cells before applying color. */
+export function fitLine(value, columns = 80) {
+  return truncate(clean(value), Math.max(1, (columns || 80) - 1));
+}
+
+/** Leave the final terminal cell empty to prevent automatic wrapping at the right edge. */
+export function formatTable(fields, inputRows, columns = 80, { wrapCells = false, boxed = false, color = false, cellColor, headerColor = '1;36', borderColor = '90' } = {}) {
+  const available = Math.max(1, (Number.isFinite(columns) && columns > 0 ? Math.floor(columns) : 80) - 1);
+  if (!inputRows.length) return wrap('暂无任务，请使用 shipwatch start 添加。', available).join('\n') + '\n';
+  const rows = inputRows.map((row) => row.map(clean));
+  const sizes = fields.map(width);
+  const separator = ' | ';
+  const minimum = sizes.reduce((total, size) => total + size, 0) + separator.length * (fields.length - 1) + (boxed ? 4 : 0);
+  if (minimum > available) {
+    return rows.map((row) => fields.flatMap((field, index) => wrap(`${field}: ${row[index]}`, available)).join('\n')).join('\n\n') + '\n';
+  }
+  let remaining = available - minimum;
+  // Keep names/status/timestamps readable, then give the path every remaining cell.
+  for (const index of fields.length === 4 ? [0, 1, 3, 2] : fields.map((_, index) => index)) {
+    const desired = rows.reduce((longest, row) => Math.max(longest, width(row[index])), sizes[index]);
+    const extra = Math.min(remaining, desired - sizes[index]);
+    sizes[index] += extra; remaining -= extra;
+  }
+  // PM2 cli-tableau: grey Unicode borders, one-cell side padding, cyan bold headings.
+  const paint = (value, code) => color && code ? `\u001b[${code}m${value}\u001b[0m` : value;
+  const edge = (value) => paint(value, borderColor);
+  const render = (row, rowIndex = -1) => {
+    const values = row.map((value, index) => {
+      const visible = truncate(value, sizes[index], index === 2);
+      const padded = visible + ' '.repeat(sizes[index] - width(visible));
+      return paint(padded, rowIndex === -1 ? headerColor : cellColor?.(index, rowIndex));
+    });
+    return boxed ? edge('│') + ' ' + values.join(' ' + edge('│') + ' ') + ' ' + edge('│') : values.join(separator).trimEnd();
+  };
+  // Detail views wrap long values so copying a path never loses its middle components.
+  const renderedRows = wrapCells ? rows.flatMap((row, rowIndex) => {
+    const lines = row.map((value, index) => wrap(value, sizes[index]));
+    return Array.from({ length: Math.max(...lines.map((items) => items.length)) }, (_, line) => render(lines.map((items) => items[line] ?? ''), rowIndex));
+  }) : rows.map(render);
+  if (boxed) {
+    const border = (left, middle, right) => edge(left + sizes.map((size) => '─'.repeat(size + 2)).join(middle) + right);
+    return [border('┌', '┬', '┐'), render(fields), border('├', '┼', '┤'), ...renderedRows, border('└', '┴', '┘')].join('\n') + '\n';
+  }
+  return [render(fields), sizes.map((size) => '-'.repeat(size)).join('-+-'), ...renderedRows].join('\n') + '\n';
+}
+
+/** Human task overview; JSON protocol keeps the original field and status values. */
+export function formatTaskList(tasks, columns = 80, { color = colorLevel() > 0 } = {}) {
+  const level = color ? colorLevel() || 1 : 0;
+  return formatTable(fields, tasks.map((task) => [task.id, task.name, `${stateMark(task.status)} ${statusText(task.status)}`, task.deployMode === 'auto' ? '开启' : task.deployMode === 'manual' ? '关闭' : '-', task.autoDeployCount ?? 0, formatTime(task.startedAt)]), columns, {
+    boxed: true, color,
+    headerColor: toneCode('cyan', level, true), borderColor: toneCode('border', level),
+    cellColor: (column, row) => column === 0 ? toneCode('cyan', level, true) : column === 2 ? toneCode(stateTone(tasks[row]?.status), level, true) : column === 3 ? toneCode(tasks[row]?.deployMode === 'auto' ? 'green' : 'muted', level) : column === 5 ? toneCode('muted', level) : undefined,
+  });
+}
+
+/** Display local time without changing stored UTC timestamps. */
+export function formatTime(value) {
+  if (!value) return '-';
+  const date = new Date(value);
+  if (!Number.isFinite(date.getTime())) return '-';
+  const pad = (number) => String(number).padStart(2, '0');
+  return `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+export function statusText(value) {
+  return ({ watching: '监听中', idle: '等待手动发布', deploying: '发布中', stopped: '已停止', error: '异常', success: '成功', failed: '失败', canceled: '已取消' })[value] ?? value ?? '-';
+}
+
+/** A vertical table keeps all timing fields readable on ordinary 80-column terminals. */
+export function formatReport(report, columns = 80) {
+  const level = colorLevel();
+  const style = { color: level > 0, wrapCells: true, headerColor: toneCode('cyan', level, true), borderColor: toneCode('border', level), cellColor: (column) => column === 0 ? toneCode('muted', level) : undefined };
+  const seconds = (value) => Number.isFinite(value) ? `${(value / 1000).toFixed(3)} 秒` : '-';
+  let output = formatTable(['项目', '内容'], [
+    ['任务名称', report.name ?? '-'], ['本地目录', report.directory ?? '-'], ['文件总数', report.totalFiles ?? report.results?.[0]?.totalFiles], ['发布状态', statusText(report.status)],
+    ...(report.detectedAt ? [['本地检测时间', formatTime(report.detectedAt)], ['发布成功时间', formatTime(report.publishedAt)], ['检测到发布成功耗时', seconds(report.detectionToPublishMs)]] : []),
+    ['开始时间', formatTime(report.startedAt)], ['结束时间', formatTime(report.endedAt)], ['整个过程耗时', seconds(report.durationMs)], ...(report.error ? [['错误详情', report.error]] : []),
+  ], columns, style);
+  if (level) {
+    const title = `${report.status === 'success' ? '✅' : report.status === 'failed' ? '⚠' : '◈'} 发布报告 · ${report.name ?? '-'} · ${statusText(report.status)}`;
+    const total = report.detectionToPublishMs ?? report.durationMs;
+    output = tint(fitLine(title, columns), stateTone(report.status), level, true) + '\n' + (Number.isFinite(total) ? tint(report.detectionToPublishMs !== undefined ? '检测 → 发布成功  ' : '发布过程耗时  ', 'muted', level) + gradient(seconds(total), level) + '\n' : '') + '\n' + output;
+  }
+  for (const result of report.results ?? []) output += '\n' + formatTable(['服务器', result.server ?? '-'], [
+    ['发布状态', statusText(result.status)], ['文件总数', result.totalFiles], ['更新文件数', result.updatedFiles], ['删除文件数', result.deletedFiles],
+    ['开始时间', formatTime(result.startedAt)], ['结束时间', formatTime(result.endedAt)], ['服务器发布耗时', seconds(result.durationMs)], ['上传耗时（含重试）', seconds(result.uploadMs)],
+    ...(result.error ? [['错误详情', result.error]] : []),
+  ], columns, { ...style, cellColor: (column, row) => column === 0 ? toneCode('muted', level) : row === 0 ? toneCode(stateTone(result.status), level, true) : undefined });
+  return output;
+}

package/src/task.js

@@ -0,0 +1,142 @@
+/** Task runtime: serialized polling, debounce, deployment state and cancellation.
+ * Exports Task; depends on snapshot/deploy and timers; filesystem polling handles nested trees.
+ */
+import { setTimeout as delay } from 'node:timers/promises';
+import { scan, snapshot } from './snapshot.js';
+import { deploy } from './deploy.js';
+import { randomUUID } from 'node:crypto';
+
+export class Task {
+  /** Inject services for deterministic failure and lifecycle tests. */
+  constructor(config, log, services = { scan, snapshot, deploy }, { autoDeployCount = 0, onAutoDeploy } = {}) {
+    this.config = config;
+    this.log = (level, message, server) => log(level, message, server);
+    this.services = services;
+    this.state = { name: config.name, directory: config.directory, status: 'stopped', running: false, results: [], deployMode: config.deployMode ?? 'auto' };
+    this.state.autoDeployCount = autoDeployCount;
+    this.state.instanceId = randomUUID();
+    this.state.deploySequence = 0;
+    this.state.completedReports = [];
+    this.onAutoDeploy = onAutoDeploy;
+    this.force = false;
+  }
+
+  /** Start once; automatic mode publishes stable changes, manual mode waits for trigger(). */
+  start() {
+    if (this.state.running) return;
+    this.controller = new AbortController();
+    this.state.running = true;
+    this.state.status = this.config.deployMode === 'manual' ? 'idle' : 'watching';
+    this.state.startedAt = new Date().toISOString();
+    this.loopPromise = this.loop().catch((error) => {
+      this.state.status = 'error';
+      this.log('error', `Task loop failed: ${error.message}`);
+    }).finally(() => { this.state.running = false; });
+  }
+
+  /** Cancel transfers and backoff, then wait until remote cleanup has finished. */
+  async stop() {
+    this.controller?.abort();
+    await this.loopPromise;
+    this.state.running = false;
+    this.state.status = 'stopped';
+    this.log('info', 'Task stopped');
+  }
+
+  /** Queue a publication; concurrent requests coalesce into one follow-up deployment. */
+  trigger() {
+    if (!this.state.running) throw new Error('Task is stopped; restart it first');
+    this.force = true;
+    return { sequence: this.state.deploySequence + 1, instanceId: this.state.instanceId };
+  }
+
+  /** Apply persisted mode without restarting or interrupting a publication already in progress. */
+  setDeployMode(mode) {
+    this.config.deployMode = mode;
+    this.state.deployMode = mode;
+    if (this.state.running && ['watching', 'idle'].includes(this.state.status)) this.state.status = mode === 'manual' ? 'idle' : 'watching';
+  }
+
+  /** One loop per task prevents overlapping snapshots, publications and source scan races. */
+  async loop() {
+    const signal = this.controller.signal;
+    let observed;
+    let changedAt = Date.now();
+    let pendingChange;
+    let attempted;
+    while (!signal.aborted) {
+      try {
+        if (this.config.deployMode === 'manual' && !this.force) {
+          await delay(this.config.intervalMs, undefined, { signal });
+          continue;
+        }
+        const current = await this.services.scan(this.config);
+        if (signal.aborted) break;
+        if (observed !== current.digest) {
+          observed = current.digest; changedAt = Date.now();
+          // Keep the first detection in a debounced batch rather than restarting its elapsed time.
+          pendingChange ??= { detectedAt: new Date().toISOString(), clock: performance.now() };
+        }
+        if (((this.config.deployMode !== 'manual' && attempted !== observed) || this.force) && Date.now() - changedAt >= this.config.debounceMs) {
+          // Count automatic rounds once before snapshotting; manual triggers and server retries are excluded.
+          if (!this.force) {
+            const count = this.state.autoDeployCount + 1;
+            this.onAutoDeploy?.(count);
+            this.state.autoDeployCount = count;
+          }
+          const detected = this.force ? undefined : pendingChange;
+          this.force = false;
+          let captured;
+          const startedAt = new Date().toISOString();
+          const started = performance.now();
+          const sequence = ++this.state.deploySequence;
+          this.state.progress = { phase: 'snapshot', servers: {} };
+          this.state.results = [];
+          this.state.summary = { name: this.config.name, directory: this.config.directory, startedAt, detectedAt: detected?.detectedAt, status: 'deploying' };
+          let failure;
+          let publishedAt;
+          let detectionToPublishMs;
+          this.state.status = 'deploying';
+          try {
+            captured = await this.services.snapshot(this.config);
+            this.state.summary.totalFiles = captured.totalFiles;
+            signal.throwIfAborted();
+            this.state.results = await this.services.deploy(this.config, captured, this.log, signal, undefined, (progress) => {
+              this.state.progress.phase = 'deploying';
+              this.state.progress.servers[progress.server] = progress;
+            });
+            if (this.state.results.length && this.state.results.every((result) => result.status === 'success')) {
+              publishedAt = new Date().toISOString();
+              if (detected) detectionToPublishMs = performance.now() - detected.clock;
+            }
+            pendingChange = undefined;
+            attempted = captured.digest;
+            this.state.lastDeployAt = new Date().toISOString();
+            this.state.status = this.state.results.every((result) => result.status === 'success') ? 'watching' : 'error';
+            if (this.state.status === 'watching') {
+              delete this.state.lastError;
+              if (this.config.deployMode === 'manual') this.state.status = 'idle';
+            }
+
+          } catch (error) { failure = error.message; throw error; }
+          finally {
+            this.state.progress.phase = 'cleanup';
+            try { await captured?.cleanup(); }
+            catch (error) { failure ??= error.message; this.state.status = 'error'; this.state.lastError = error.message; }
+            this.state.summary = { name: this.config.name, directory: this.config.directory, startedAt, detectedAt: detected?.detectedAt, publishedAt, detectionToPublishMs, totalFiles: captured?.totalFiles ?? this.state.results[0]?.totalFiles, error: failure, endedAt: new Date().toISOString(), durationMs: performance.now() - started, status: this.state.results.length && this.state.results.every((r) => r.status === 'success') ? 'success' : signal.aborted ? 'canceled' : 'failed', results: this.state.results };
+            if (failure) this.state.summary.status = signal.aborted ? 'canceled' : 'failed';
+            this.log(this.state.summary.status === 'success' ? 'info' : 'error', `SHIPWATCH_REPORT ${JSON.stringify(this.state.summary)}`);
+            this.state.progress.phase = this.state.summary.status;
+            // A follower must observe its own queued round even if another publication starts quickly.
+            this.state.completedReports.push({ sequence, report: this.state.summary });
+            this.state.completedReports = this.state.completedReports.slice(-10);
+          }
+        }
+      } catch (error) {
+        if (!signal.aborted) { this.state.status = 'error'; this.state.lastError = error.message; this.log('error', error.message); }
+      }
+      try { await delay(this.config.intervalMs, undefined, { signal }); }
+      catch { break; /* stop() interrupts the polling sleep. */ }
+    }
+  }
+}

package/src/terminal.js

@@ -0,0 +1,66 @@
+/** Shared terminal theme: approved cyan/blue/purple accents, ANSI fallbacks and plain-text output.
+ * Exports color helpers and notifications; never writes backgrounds or changes JSON output.
+ */
+import { stripVTControlCharacters } from 'node:util';
+
+const palette = { cyan: [101, 220, 233], blue: [122, 171, 255], purple: [191, 155, 250], green: [139, 214, 165], yellow: [232, 199, 126], red: [239, 140, 157], muted: [135, 149, 170], border: [83, 97, 116] };
+const basic = { cyan: 36, blue: 34, purple: 35, green: 32, yellow: 33, red: 31, muted: 90, border: 90 };
+
+/** Respect output capabilities; redirected/dumb/NO_COLOR sessions get no decoration. */
+export function colorLevel(stream = process.stdout, env = process.env) {
+  if (!stream.isTTY || Object.hasOwn(env, 'NO_COLOR') || env.TERM === 'dumb') return 0;
+  if (/truecolor|24bit/i.test(env.COLORTERM ?? '')) return 3;
+  return /256color/i.test(env.TERM ?? '') ? 2 : 1;
+}
+
+export function cleanText(value) {
+  return stripVTControlCharacters(String(value ?? '')).replace(/[\x00-\x1f\x7f-\x9f\u202a-\u202e\u2066-\u2069]/g, ' ');
+}
+
+function rgbCode(rgb, level) {
+  if (level === 3) return `38;2;${rgb.join(';')}`;
+  const [r, g, b] = rgb.map((value) => Math.round(value / 255 * 5));
+  return `38;5;${16 + r * 36 + g * 6 + b}`;
+}
+
+/** Return a style code separately so tables can measure unstyled cell contents first. */
+export function toneCode(tone, level = colorLevel(), bold = false) {
+  if (!level) return undefined;
+  return (bold ? '1;' : '') + (level > 1 ? rgbCode(palette[tone] ?? palette.cyan, level) : basic[tone] ?? 36);
+}
+
+export function tint(value, tone = 'cyan', level = colorLevel(), bold = false) {
+  const code = toneCode(tone, level, bold);
+  return code ? `\u001b[${code}m${value}\u001b[0m` : String(value);
+}
+
+/** Gradient is foreground-only, matching the preview while respecting each user's terminal background. */
+export function gradient(value, level = colorLevel()) {
+  const text = cleanText(value);
+  if (level < 2) return tint(text, 'cyan', level, true);
+  const chars = Array.from(text);
+  return chars.map((char, index) => {
+    const fraction = index / Math.max(1, chars.length - 1) * 2;
+    const from = fraction < 1 ? palette.cyan : palette.blue;
+    const to = fraction < 1 ? palette.blue : palette.purple;
+    const amount = fraction < 1 ? fraction : fraction - 1;
+    return `\u001b[${rgbCode(from.map((value, i) => Math.round(value + (to[i] - value) * amount)), level)}m${char}`;
+  }).join('') + '\u001b[0m';
+}
+
+export const stateTone = (status) => ({ watching: 'green', idle: 'yellow', deploying: 'blue', success: 'green', stopped: 'muted', error: 'red', failed: 'red', canceled: 'yellow' })[status] ?? 'muted';
+export const stateMark = (status) => ({ watching: '●', idle: '◌', deploying: '◈', success: '✓', stopped: '○', error: '×', failed: '×', canceled: '−' })[status] ?? '·';
+export const brand = (level = colorLevel()) => level ? gradient('SHIPWATCH', level) + '  ' + tint('v0.1.0', 'muted', level) + '\n\n' : '';
+
+/** Preserve message wording in pipes; interactive confirmations use only one status marker. */
+export function notice(message, tone = 'green', stream = process.stdout) {
+  const level = colorLevel(stream);
+  return level ? tint(`${tone === 'red' ? '✗' : tone === 'yellow' ? '⚠' : '✓'} ${message}`, tone, level) : message;
+}
+
+/** Stable project colors make mixed logs recognizable without storing any UI state. */
+export function projectTone(name) {
+  let hash = 0;
+  for (const char of String(name)) hash = (hash * 31 + char.codePointAt(0)) >>> 0;
+  return ['cyan', 'blue', 'purple'][hash % 3];
+}