artifacty 0.1.1 → 0.2.0

package/src/client/editor.js

@@ -15,7 +15,7 @@ const messages = {
   ...(globalThis.ARTIFACTY_I18N || {})
 };
 
-const SUPPORTED_FORMATS = ["markdown", "html", "json", "text", "code", "svg", "mermaid", "react"];
+const SUPPORTED_FORMATS = ["markdown", "html", "json", "text", "code", "svg", "mermaid", "react", "sarif", "csv", "image", "video"];
 
 const editorTheme = EditorView.theme({
   "&": {
@@ -128,7 +128,7 @@ function enhanceTextarea(textarea) {
   updatePreview();
 
   function updateToolbar(format) {
-    formatJsonButton.hidden = format !== "json";
+    formatJsonButton.hidden = format !== "json" && format !== "sarif";
     status.textContent = formatLabel(format);
   }
 
@@ -158,7 +158,7 @@ function enhanceTextarea(textarea) {
       return;
     }
 
-    if (format === "json") {
+    if (format === "json" || format === "sarif") {
       const pre = document.createElement("pre");
       try {
         pre.textContent = JSON.stringify(JSON.parse(content), null, 2);
@@ -191,7 +191,7 @@ function languageExtension(format) {
   if (format === "html" || format === "svg") {
     return html();
   }
-  if (format === "json") {
+  if (format === "json" || format === "sarif") {
     return json();
   }
   if (format === "markdown") {
@@ -212,6 +212,18 @@ function detectFormat({ explicit, fileName, content }) {
   if (lowerName.endsWith(".md") || lowerName.endsWith(".markdown")) {
     return "markdown";
   }
+  if (lowerName.endsWith(".sarif") || lowerName.endsWith(".sarif.json")) {
+    return "sarif";
+  }
+  if (lowerName.endsWith(".csv")) {
+    return "csv";
+  }
+  if (/\.(png|jpe?g|gif|webp)$/.test(lowerName)) {
+    return "image";
+  }
+  if (/\.(mp4|webm)$/.test(lowerName)) {
+    return "video";
+  }
   if (lowerName.endsWith(".json")) {
     return "json";
   }
@@ -241,6 +253,18 @@ function detectFormat({ explicit, fileName, content }) {
   if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html") || trimmed.startsWith("<")) {
     return "html";
   }
+  if (looksLikeSarif(trimmed)) {
+    return "sarif";
+  }
+  if (looksLikeCsv(trimmed)) {
+    return "csv";
+  }
+  if (/^data:image\/(?:png|jpeg|gif|webp);base64,/i.test(trimmed)) {
+    return "image";
+  }
+  if (/^data:video\/(?:mp4|webm);base64,/i.test(trimmed)) {
+    return "video";
+  }
   if (trimmed.startsWith("{") || trimmed.startsWith("[")) {
     return "json";
   }
@@ -255,6 +279,54 @@ function formatLabel(format) {
   return messages.mode.replaceAll("{format}", label);
 }
 
+function looksLikeSarif(value) {
+  const trimmed = String(value || "").trim();
+  if (!trimmed.startsWith("{")) {
+    return false;
+  }
+  try {
+    const parsed = JSON.parse(trimmed);
+    return parsed &&
+      typeof parsed === "object" &&
+      Array.isArray(parsed.runs) &&
+      (typeof parsed.version === "string" || String(parsed.$schema || "").toLowerCase().includes("sarif"));
+  } catch {
+    return false;
+  }
+}
+
+function looksLikeCsv(value) {
+  const lines = String(value || "")
+    .trim()
+    .split(/\r?\n/)
+    .map((line) => line.trimEnd())
+    .filter(Boolean)
+    .slice(0, 5);
+  if (lines.length < 2 || lines[0].trimStart().startsWith("|")) {
+    return false;
+  }
+  const counts = lines.map(csvFieldCount);
+  return counts[0] > 1 && counts.every((count) => count === counts[0]);
+}
+
+function csvFieldCount(line) {
+  let count = 1;
+  let inQuotes = false;
+  for (let index = 0; index < line.length; index += 1) {
+    const char = line[index];
+    if (char === "\"") {
+      if (inQuotes && line[index + 1] === "\"") {
+        index += 1;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (char === "," && !inQuotes) {
+      count += 1;
+    }
+  }
+  return count;
+}
+
 function invalidJsonMessage(error) {
   return messages.invalidJson.replaceAll("{message}", error.message);
 }

package/src/lib/background.js

@@ -0,0 +1,344 @@
+import { execFile, spawn } from "node:child_process";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { createStore } from "./storage.js";
+import { readServerState, serverStatePath } from "./server-state.js";
+
+const DEFAULT_READY_TIMEOUT_MS = 5000;
+
+export async function startBackgroundServer(options = {}) {
+  if (options.generateToken && options.apiToken) {
+    throw new Error("Use either --api-token or --generate-token, not both");
+  }
+
+  const store = createStore({ home: options.home });
+  const paths = backgroundPaths(store);
+  const current = await backgroundStatus({ home: store.home });
+  if (current.running) {
+    throw new Error(`Artifacty server is already running on ${current.url || "unknown URL"} (pid ${current.pid})`);
+  }
+
+  mkdirSync(paths.logDir, { recursive: true });
+  mkdirSync(store.home, { recursive: true });
+
+  const child = spawnDetachedServer(options, store, paths);
+
+  writeFileSync(paths.pidFile, `${child.pid}\n`, "utf8");
+
+  try {
+    const ready = await waitForReady({
+      store,
+      pid: child.pid,
+      timeoutMs: Number(options.timeout || DEFAULT_READY_TIMEOUT_MS)
+    });
+    child.unref();
+    return {
+      action: "start",
+      running: true,
+      pid: child.pid,
+      url: ready.url,
+      home: store.home,
+      logs: {
+        stdout: paths.stdoutLog,
+        stderr: paths.stderrLog
+      },
+      statePath: serverStatePath(store)
+    };
+  } catch (error) {
+    try {
+      await terminatePid(child.pid);
+    } catch {
+      // Process may already have exited during startup.
+    }
+    rmSync(paths.pidFile, { force: true });
+    const logTail = await tailFile(paths.stderrLog);
+    const message = logTail ? `${error.message}\n${logTail}` : error.message;
+    throw new Error(message);
+  }
+}
+
+export async function stopBackgroundServer(options = {}) {
+  const store = createStore({ home: options.home });
+  const paths = backgroundPaths(store);
+  const status = await backgroundStatus({ home: store.home });
+
+  if (!status.pid || !status.pidFileExists) {
+    return {
+      action: "stop",
+      stopped: false,
+      running: status.running,
+      reason: status.pid ? "server was not started by artifacty start" : "server is not running",
+      pid: status.pid || null,
+      home: store.home
+    };
+  }
+
+  if (!status.processRunning) {
+    rmSync(paths.pidFile, { force: true });
+    return {
+      action: "stop",
+      stopped: false,
+      running: false,
+      reason: "removed stale pid file",
+      pid: status.pid,
+      home: store.home
+    };
+  }
+
+  if (!options.force && !status.stateMatchesPid && !status.healthy) {
+    return {
+      action: "stop",
+      stopped: false,
+      running: status.running,
+      reason: "pid file does not match a healthy Artifacty server; retry with --force to stop the recorded pid",
+      pid: status.pid,
+      home: store.home
+    };
+  }
+
+  await terminatePid(status.pid);
+  let stopped = await waitForStop(status.pid, Number(options.timeout || DEFAULT_READY_TIMEOUT_MS));
+  if (!stopped && options.force) {
+    await terminatePid(status.pid, { force: true });
+    stopped = await waitForStop(status.pid, 1000);
+  }
+  if (!stopped) {
+    return {
+      action: "stop",
+      stopped: false,
+      running: true,
+      reason: "server did not stop before timeout; retry with --force",
+      pid: status.pid,
+      home: store.home
+    };
+  }
+  rmSync(paths.pidFile, { force: true });
+
+  return {
+    action: "stop",
+    stopped: true,
+    running: false,
+    pid: status.pid,
+    home: store.home
+  };
+}
+
+export async function backgroundStatus(options = {}) {
+  const store = createStore({ home: options.home });
+  const paths = backgroundPaths(store);
+  const state = await readServerState(store);
+  const pidFromFile = readPidFile(paths.pidFile);
+  const pid = pidFromFile || state?.pid || null;
+  const processRunning = pid ? isPidRunning(pid) : false;
+  const health = state?.url ? await fetchHealth(state.url) : { ok: false };
+  const stateMatchesPid = Boolean(pid && state?.pid === pid);
+
+  return {
+    action: "status",
+    running: Boolean(processRunning && health.ok),
+    processRunning,
+    healthy: Boolean(health.ok),
+    platform: process.platform,
+    pid,
+    statePid: state?.pid || null,
+    stateMatchesPid,
+    pidFileExists: existsSync(paths.pidFile),
+    managed: Boolean(pidFromFile),
+    url: state?.url || null,
+    home: store.home,
+    logs: {
+      stdout: paths.stdoutLog,
+      stderr: paths.stderrLog
+    },
+    statePath: serverStatePath(store)
+  };
+}
+
+export function backgroundPaths(store) {
+  const logDir = path.join(store.home, "logs");
+  return {
+    logDir,
+    pidFile: path.join(store.home, "server.pid"),
+    stdoutLog: path.join(logDir, "server.out.log"),
+    stderrLog: path.join(logDir, "server.err.log")
+  };
+}
+
+export function stopCommandForPlatform(pid, options = {}, platform = process.platform) {
+  if (platform !== "win32") {
+    return null;
+  }
+  const args = ["/PID", String(pid), "/T"];
+  if (options.force) {
+    args.push("/F");
+  }
+  return { command: "taskkill", args };
+}
+
+function spawnDetachedServer(options, store, paths) {
+  let stdoutFd;
+  let stderrFd;
+  try {
+    stdoutFd = openSync(paths.stdoutLog, "a");
+    stderrFd = openSync(paths.stderrLog, "a");
+    return spawn(process.execPath, buildServerArgs(options, store), {
+      detached: true,
+      env: buildServerEnv(options),
+      stdio: ["ignore", stdoutFd, stderrFd],
+      windowsHide: true
+    });
+  } finally {
+    closeFd(stdoutFd);
+    closeFd(stderrFd);
+  }
+}
+
+export function buildServerArgs(options, store) {
+  const args = [options.serverPath];
+  addValueArg(args, "--host", options.host);
+  addValueArg(args, "--port", options.port);
+  addValueArg(args, "--home", store.home);
+  addValueArg(args, "--share-mode", options.shareMode);
+  addValueArg(args, "--bytes", options.bytes);
+  if (options.generateToken) {
+    args.push("--generate-token");
+  }
+  if (options.allowSecrets) {
+    args.push("--allow-secrets");
+  }
+  return args;
+}
+
+function buildServerEnv(options) {
+  return {
+    ...process.env,
+    ...(options.apiToken ? { ARTIFACTY_API_TOKEN: options.apiToken } : {})
+  };
+}
+
+async function terminatePid(pid, options = {}) {
+  const command = stopCommandForPlatform(pid, options);
+  if (command) {
+    await execFileQuiet(command.command, command.args).catch((error) => {
+      if (!isPidRunning(pid)) {
+        return;
+      }
+      throw new Error(`Failed to stop Windows process ${pid}: ${error.stderr || error.message}`);
+    });
+    return;
+  }
+
+  const signal = options.force ? "SIGKILL" : "SIGTERM";
+  try {
+    process.kill(-pid, signal);
+  } catch {
+    try {
+      process.kill(pid, signal);
+    } catch (error) {
+      if (error.code !== "ESRCH") {
+        throw error;
+      }
+    }
+  }
+}
+
+function execFileQuiet(command, args) {
+  return new Promise((resolve, reject) => {
+    execFile(command, args, { windowsHide: true }, (error, stdout, stderr) => {
+      if (error) {
+        reject(Object.assign(error, { stdout, stderr }));
+        return;
+      }
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+function addValueArg(args, name, value) {
+  if (value !== undefined && value !== null && value !== "") {
+    args.push(name, String(value));
+  }
+}
+
+async function waitForReady({ store, pid, timeoutMs }) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidRunning(pid)) {
+      throw new Error("Artifacty server exited before it became ready");
+    }
+    const state = await readServerState(store);
+    if (state?.pid === pid && state.url) {
+      const health = await fetchHealth(state.url);
+      if (health.ok) {
+        return state;
+      }
+    }
+    await delay(100);
+  }
+  throw new Error(`Timed out waiting for Artifacty server to become ready after ${timeoutMs}ms`);
+}
+
+async function waitForStop(pid, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    if (!isPidRunning(pid)) {
+      return true;
+    }
+    await delay(100);
+  }
+  return !isPidRunning(pid);
+}
+
+function readPidFile(pidFile) {
+  try {
+    const pid = Number(readFileSync(pidFile, "utf8").trim());
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+function isPidRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+
+async function fetchHealth(url) {
+  try {
+    const response = await fetch(`${url}/health`, {
+      signal: AbortSignal.timeout(500)
+    });
+    return { ok: response.ok, status: response.status };
+  } catch {
+    return { ok: false };
+  }
+}
+
+async function tailFile(file, maxBytes = 2000) {
+  try {
+    const content = await readFile(file, "utf8");
+    return content.slice(-maxBytes).trim();
+  } catch {
+    return "";
+  }
+}
+
+function delay(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function closeFd(fd) {
+  if (typeof fd !== "number") {
+    return;
+  }
+  try {
+    closeSync(fd);
+  } catch {
+    // The child inherited the descriptor; parent cleanup is best effort.
+  }
+}