codeharbor 0.1.17 → 0.1.19

package/README.md

@@ -93,6 +93,8 @@ Notes:
 - Service commands auto-elevate with `sudo` when root privileges are required.
 - `codeharbor service install --with-admin` and `install-linux-easy.sh --enable-admin-service` now install
   `/etc/sudoers.d/codeharbor-restart` for non-root service users, so Admin UI restart actions work out-of-box.
+- `npm install -g codeharbor@latest` now performs best-effort restart for active `codeharbor(.service)` units on Linux
+  so upgrades take effect immediately (set `CODEHARBOR_SKIP_POSTINSTALL_RESTART=1` to disable).
 - If your environment blocks interactive `sudo`, use explicit fallback:
   - `sudo <node-bin> <codeharbor-cli-script> service ...`
 

package/dist/cli.js

@@ -3128,7 +3128,7 @@ function renderMatrixHtml(body, msgtype) {
   let match;
   while ((match = codeFencePattern.exec(normalized)) !== null) {
     const before = normalized.slice(cursor, match.index);
-    const renderedBefore = renderTextSection(before);
+    const renderedBefore = renderMarkdownSection(before);
     if (renderedBefore) {
       sections.push(renderedBefore);
     }
@@ -3141,29 +3141,142 @@ function renderMatrixHtml(body, msgtype) {
     cursor = match.index + match[0].length;
   }
   const tail = normalized.slice(cursor);
-  const renderedTail = renderTextSection(tail);
+  const renderedTail = renderMarkdownSection(tail);
   if (renderedTail) {
     sections.push(renderedTail);
   }
   if (sections.length === 0) {
     sections.push("<p>(\u7A7A\u6D88\u606F)</p>");
   }
-  const badge = msgtype === "m.notice" ? `<p><font color="#8a5a00"><b>\u{1F4E3} CodeHarbor \u63D0\u793A</b></font></p>` : `<p><font color="#1f7a5a"><b>\u{1F916} AI \u56DE\u590D</b></font></p>`;
+  const badge = msgtype === "m.notice" ? `<p><font color="#8a5a00"><b>CodeHarbor \u63D0\u793A</b></font></p>` : `<p><font color="#1f7a5a"><b>CodeHarbor AI \u56DE\u590D</b></font></p>`;
   return `<div>${badge}${sections.join("")}</div>`;
 }
-function renderTextSection(raw) {
+function renderMarkdownSection(raw) {
   if (!raw.trim()) {
     return "";
   }
-  const normalized = raw.replace(/\r\n/g, "\n").trim();
-  const paragraphs = normalized.split(/\n{2,}/);
-  const rendered = paragraphs.map((paragraph) => {
-    const escaped = escapeHtml(paragraph);
-    const inlineCode = escaped.replace(/`([^`\n]+)`/g, "<code>$1</code>");
-    return `<p>${inlineCode.replace(/\n/g, "<br/>")}</p>`;
-  }).join("");
+  const lines = raw.replace(/\r\n/g, "\n").trim().split("\n");
+  const blocks = [];
+  let index = 0;
+  while (index < lines.length) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (!trimmed) {
+      index += 1;
+      continue;
+    }
+    const headingMatch = /^(#{1,6})\s+(.+)$/.exec(trimmed);
+    if (headingMatch) {
+      const level = Math.min(6, headingMatch[1].length + 1);
+      blocks.push(`<h${level}>${renderInlineMarkup(headingMatch[2])}</h${level}>`);
+      index += 1;
+      continue;
+    }
+    if (/^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+      blocks.push("<hr/>");
+      index += 1;
+      continue;
+    }
+    if (/^>\s?/.test(trimmed)) {
+      const quoteLines = [];
+      while (index < lines.length) {
+        const current = lines[index].trim();
+        if (!current) {
+          break;
+        }
+        if (!/^>\s?/.test(current)) {
+          break;
+        }
+        quoteLines.push(current.replace(/^>\s?/, ""));
+        index += 1;
+      }
+      if (quoteLines.length > 0) {
+        blocks.push(`<blockquote><p>${quoteLines.map((entry) => renderInlineMarkup(entry)).join("<br/>")}</p></blockquote>`);
+      }
+      continue;
+    }
+    if (/^\s*[-*]\s+/.test(line)) {
+      const items = [];
+      while (index < lines.length && /^\s*[-*]\s+/.test(lines[index])) {
+        items.push(lines[index].replace(/^\s*[-*]\s+/, "").trim());
+        index += 1;
+      }
+      blocks.push(`<ul>${items.map((item) => `<li>${renderInlineMarkup(item)}</li>`).join("")}</ul>`);
+      continue;
+    }
+    if (/^\s*\d+\.\s+/.test(line)) {
+      const items = [];
+      while (index < lines.length && /^\s*\d+\.\s+/.test(lines[index])) {
+        items.push(lines[index].replace(/^\s*\d+\.\s+/, "").trim());
+        index += 1;
+      }
+      blocks.push(`<ol>${items.map((item) => `<li>${renderInlineMarkup(item)}</li>`).join("")}</ol>`);
+      continue;
+    }
+    const paragraphLines = [];
+    while (index < lines.length) {
+      const current = lines[index];
+      if (!current.trim()) {
+        break;
+      }
+      if (isBlockBoundaryLine(current)) {
+        break;
+      }
+      paragraphLines.push(current.trimEnd());
+      index += 1;
+    }
+    if (paragraphLines.length > 0) {
+      blocks.push(`<p>${paragraphLines.map((entry) => renderInlineMarkup(entry)).join("<br/>")}</p>`);
+      continue;
+    }
+    index += 1;
+  }
+  return blocks.join("");
+}
+function isBlockBoundaryLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) {
+    return false;
+  }
+  return /^(#{1,6})\s+/.test(trimmed) || /^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed) || /^>\s?/.test(trimmed) || /^\s*[-*]\s+/.test(trimmed) || /^\s*\d+\.\s+/.test(trimmed);
+}
+function renderInlineMarkup(raw) {
+  if (!raw) {
+    return "";
+  }
+  const inlineCodeSegments = [];
+  const withPlaceholders = raw.replace(/`([^`\n]+)`/g, (_match, code) => {
+    const token = `@@CHCODE${inlineCodeSegments.length}@@`;
+    inlineCodeSegments.push(`<code>${escapeHtml(code)}</code>`);
+    return token;
+  });
+  let rendered = escapeHtml(withPlaceholders);
+  rendered = rendered.replace(/\[([^\]\n]+)\]\((https?:\/\/[^\s)]+)\)/g, (_match, label, url) => {
+    const safeUrl = sanitizeLinkUrl(url);
+    if (!safeUrl) {
+      return escapeHtml(label);
+    }
+    return `<a href="${escapeHtml(safeUrl)}">${escapeHtml(label)}</a>`;
+  });
+  rendered = rendered.replace(/\*\*([^*\n]+)\*\*/g, "<strong>$1</strong>");
+  rendered = rendered.replace(/(^|[^*])\*([^*\n]+)\*/g, "$1<em>$2</em>");
+  rendered = rendered.replace(/(^|[^_])_([^_\n]+)_/g, "$1<em>$2</em>");
+  for (let i = 0; i < inlineCodeSegments.length; i += 1) {
+    rendered = rendered.replace(`@@CHCODE${i}@@`, inlineCodeSegments[i]);
+  }
   return rendered;
 }
+function sanitizeLinkUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return null;
+    }
+    return parsed.toString();
+  } catch {
+    return null;
+  }
+}
 function escapeHtml(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codeharbor",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Instant-messaging bridge for Codex CLI sessions",
   "license": "MIT",
   "main": "dist/cli.js",
@@ -17,6 +17,7 @@
   },
   "files": [
     "dist",
+    "scripts/postinstall-restart.cjs",
     ".env.example",
     "README.md",
     "LICENSE"
@@ -55,6 +56,7 @@
     "e2e:install": "playwright install chromium",
     "test:watch": "vitest test",
     "test:legacy": "bash ./scripts/run-legacy-tests.sh",
+    "postinstall": "node ./scripts/postinstall-restart.cjs",
     "prepare": "npm run build",
     "prepublishOnly": "npm run changelog:check && npm run typecheck && npm run lint && npm run test:coverage && npm run build",
     "changelog:check": "bash ./scripts/check-changelog.sh",

package/scripts/postinstall-restart.cjs

@@ -0,0 +1,134 @@
+#!/usr/bin/env node
+"use strict";
+
+const { execFileSync } = require("node:child_process");
+
+const LOG_PREFIX = "[codeharbor postinstall]";
+const MAIN_SERVICE = "codeharbor.service";
+const ADMIN_SERVICE = "codeharbor-admin.service";
+
+function isTruthy(value) {
+  if (!value) {
+    return false;
+  }
+  const normalized = String(value).trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+
+function isGlobalInstall() {
+  return isTruthy(process.env.npm_config_global);
+}
+
+function hasRootPrivileges() {
+  if (typeof process.getuid !== "function") {
+    return true;
+  }
+  return process.getuid() === 0;
+}
+
+function commandExists(file) {
+  try {
+    execFileSync(file, ["--version"], { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function runCommand(file, args, options) {
+  return execFileSync(file, args, {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    ...options,
+  });
+}
+
+function listUnitFiles(unitName) {
+  try {
+    return runCommand("systemctl", ["list-unit-files", unitName, "--no-legend", "--no-pager"]);
+  } catch {
+    return "";
+  }
+}
+
+function isUnitInstalled(unitName) {
+  const output = listUnitFiles(unitName).trim();
+  if (!output) {
+    return false;
+  }
+  return output.split(/\r?\n/).some((line) => line.trim().startsWith(unitName));
+}
+
+function isUnitActive(unitName) {
+  try {
+    const output = runCommand("systemctl", ["is-active", unitName], {}).trim();
+    return output === "active";
+  } catch {
+    return false;
+  }
+}
+
+function restartUnit(unitName) {
+  if (hasRootPrivileges()) {
+    runCommand("systemctl", ["restart", unitName], {});
+    return;
+  }
+
+  runCommand("sudo", ["-n", "systemctl", "restart", unitName], {});
+}
+
+function main() {
+  if (isTruthy(process.env.CODEHARBOR_SKIP_POSTINSTALL_RESTART)) {
+    console.log(`${LOG_PREFIX} skip restart: CODEHARBOR_SKIP_POSTINSTALL_RESTART is set.`);
+    return;
+  }
+
+  const forceRestart = isTruthy(process.env.CODEHARBOR_FORCE_POSTINSTALL_RESTART);
+  if (!forceRestart && !isGlobalInstall()) {
+    return;
+  }
+
+  if (process.platform !== "linux") {
+    return;
+  }
+
+  if (!commandExists("systemctl")) {
+    return;
+  }
+
+  const candidates = [MAIN_SERVICE, ADMIN_SERVICE].filter((unitName) => isUnitInstalled(unitName));
+  const activeUnits = candidates.filter((unitName) => isUnitActive(unitName));
+  if (activeUnits.length === 0) {
+    return;
+  }
+
+  const restarted = [];
+  const failed = [];
+
+  for (const unitName of activeUnits) {
+    try {
+      restartUnit(unitName);
+      restarted.push(unitName);
+    } catch (error) {
+      failed.push({ unitName, error });
+    }
+  }
+
+  if (restarted.length > 0) {
+    console.log(`${LOG_PREFIX} restarted: ${restarted.join(", ")}`);
+  }
+  if (failed.length > 0) {
+    for (const failure of failed) {
+      const message = failure.error instanceof Error ? failure.error.message : String(failure.error);
+      console.warn(`${LOG_PREFIX} failed to restart ${failure.unitName}: ${message}`);
+    }
+    console.warn(`${LOG_PREFIX} run "codeharbor service restart --with-admin" manually if needed.`);
+  }
+}
+
+try {
+  main();
+} catch (error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.warn(`${LOG_PREFIX} unexpected error: ${message}`);
+}