artifacty 0.1.0 → 0.1.2

package/scripts/smoke.sh

@@ -74,6 +74,7 @@ assert(response.status === 201, `expected create status 201, got ${response.stat
 const created = await response.json();
 assert(created.id && created.rawUrl, "create response missing artifact URLs");
 
+const fakeGithubToken = ["ghp", "abcdefghijklmnopqrstuvwxyz123456"].join("_");
 response = await fetch(`${url}/api/artifacts`, {
   method: "POST",
   headers: {
@@ -82,7 +83,7 @@ response = await fetch(`${url}/api/artifacts`, {
   },
   body: JSON.stringify({
     title: "Blocked Secret",
-    content: "ghp_abcdefghijklmnopqrstuvwxyz123456",
+    content: fakeGithubToken,
     format: "text"
   })
 });

package/src/cli.js

@@ -17,7 +17,9 @@ import { convertAgentArtifact } from "./lib/converters.js";
 import { checkMcpTools } from "./lib/check.js";
 import { installAgent } from "./lib/installer.js";
 import { serviceCommand } from "./lib/service.js";
+import { backgroundStatus, startBackgroundServer, stopBackgroundServer } from "./lib/background.js";
 import { resolvePublicBaseUrl } from "./lib/server-state.js";
+import { generateToken } from "./lib/token.js";
 import { startServer } from "./server.js";
 
 const PACKAGE_ROOT = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
@@ -32,17 +34,66 @@ async function main() {
     return;
   }
 
+  if (command === "token" || command === "generate-token") {
+    const token = generateToken(options);
+    if (options.raw) {
+      process.stdout.write(`${token.token}\n`);
+      return;
+    }
+    printJson(token);
+    return;
+  }
+
   if (command === "serve") {
+    if (options.detach) {
+      printJson(await startBackgroundServer({
+        ...serverOptions(options),
+        serverPath: path.join(PACKAGE_ROOT, "src", "server.js")
+      }));
+      return;
+    }
+    if (options.generateToken && options.apiToken) {
+      throw new Error("Use either --api-token or --generate-token, not both");
+    }
+    const generatedToken = options.generateToken ? generateToken(options) : null;
     const server = await startServer({
       host: options.host,
       port: options.port,
       home: options.home,
-      apiToken: options.apiToken,
+      apiToken: generatedToken?.token || options.apiToken,
       shareMode: options.shareMode,
       allowSecrets: options.allowSecrets
     });
     process.stderr.write(`Artifacty listening on ${server.url}\n`);
     process.stderr.write(`Store: ${server.store.home}\n`);
+    if (generatedToken) {
+      process.stderr.write(`API token: ${generatedToken.token}\n`);
+      process.stderr.write(`HTTP header: ${generatedToken.header}\n`);
+      process.stderr.write(`Create URL: ${server.url}/new?token=${encodeURIComponent(generatedToken.token)}\n`);
+      process.stderr.write(`Import URL: ${server.url}/import?token=${encodeURIComponent(generatedToken.token)}\n`);
+    }
+    return;
+  }
+
+  if (command === "start") {
+    printJson(await startBackgroundServer({
+      ...serverOptions(options),
+      serverPath: path.join(PACKAGE_ROOT, "src", "server.js")
+    }));
+    return;
+  }
+
+  if (command === "stop") {
+    printJson(await stopBackgroundServer({
+      home: options.home,
+      timeout: options.timeout,
+      force: options.force
+    }));
+    return;
+  }
+
+  if (command === "status") {
+    printJson(await backgroundStatus({ home: options.home }));
     return;
   }
 
@@ -235,7 +286,7 @@ function parseArgs(args) {
     }
 
     const key = arg.slice(2);
-    if (key === "raw" || key === "dry-run" || key === "trust" || key === "include-archived" || key === "allow-secrets") {
+    if (key === "raw" || key === "dry-run" || key === "trust" || key === "include-archived" || key === "allow-secrets" || key === "generate-token" || key === "detach" || key === "force") {
       options[toCamelCase(key)] = true;
       continue;
     }
@@ -247,7 +298,7 @@ function parseArgs(args) {
 
     if (key === "tag") {
       options.tag = [...(options.tag || []), value];
-    } else if (key === "port" || key === "limit" || key === "version" || key === "schema-version" || key === "timeout") {
+    } else if (key === "port" || key === "limit" || key === "version" || key === "schema-version" || key === "timeout" || key === "bytes") {
       options[toCamelCase(key)] = Number(value);
     } else {
       options[toCamelCase(key)] = value;
@@ -292,12 +343,16 @@ function printHelp() {
   process.stdout.write(`Artifacty
 
 Usage:
-  artifacty serve [--host 127.0.0.1] [--port 8787] [--home ~/.artifacty]
-  artifacty publish --title <title> (--file <path> | --content <text>) [--format html|markdown|text|json] [--source agent] [--tag tag]
-  artifacty import --agent claude|codex|gemini|auto (--file <path> | --content <text>) [--title <title>] [--format html|markdown|text|json] [--tag tag]
-  artifacty install claude|codex|gemini|all [--dry-run] [--config <path>] [--server-path <path>] [--url http://127.0.0.1:8787]
+  artifacty token [--bytes 32] [--raw]
+  artifacty serve [--host 127.0.0.1] [--port 8787] [--home ~/.artifacty] [--api-token token] [--generate-token] [--bytes 32] [--detach]
+  artifacty start [--host 127.0.0.1] [--port 8787] [--home ~/.artifacty] [--api-token token] [--timeout 5000]
+  artifacty status [--home ~/.artifacty]
+  artifacty stop [--home ~/.artifacty] [--timeout 5000] [--force]
+  artifacty publish --title <title> (--file <path> | --content <text>) [--format html|markdown|text|json|code|svg|mermaid|react] [--source agent] [--tag tag]
+  artifacty import --agent claude|codex|gemini|auto (--file <path> | --content <text>) [--title <title>] [--format html|markdown|text|json|code|svg|mermaid|react] [--tag tag]
+  artifacty install claude|codex|gemini|all [--dry-run] [--config <path>] [--server-path <path>] [--url http://127.0.0.1:8787] [--timeout 30000]
   artifacty check [--server-path <path>] [--timeout 5000]
-  artifacty update <id> (--file <path> | --content <text>) [--title <title>] [--format html|markdown|text|json]
+  artifacty update <id> (--file <path> | --content <text>) [--title <title>] [--format html|markdown|text|json|code|svg|mermaid|react]
   artifacty archive <id>
   artifacty restore <id>
   artifacty audit [--artifact <id>] [--limit 100]
@@ -331,6 +386,20 @@ function stripInstallContentUnlessDryRun(result) {
   return rest;
 }
 
+function serverOptions(options) {
+  return {
+    host: options.host,
+    port: options.port,
+    home: options.home,
+    apiToken: options.apiToken,
+    shareMode: options.shareMode,
+    allowSecrets: options.allowSecrets,
+    generateToken: options.generateToken,
+    bytes: options.bytes,
+    timeout: options.timeout
+  };
+}
+
 function toCamelCase(value) {
   return value.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
 }

package/src/client/editor.js

@@ -15,6 +15,8 @@ const messages = {
   ...(globalThis.ARTIFACTY_I18N || {})
 };
 
+const SUPPORTED_FORMATS = ["markdown", "html", "json", "text", "code", "svg", "mermaid", "react"];
+
 const editorTheme = EditorView.theme({
   "&": {
     minHeight: "52vh",
@@ -146,6 +148,16 @@ function enhanceTextarea(textarea) {
       return;
     }
 
+    if (format === "svg") {
+      const frame = document.createElement("iframe");
+      frame.className = "editor-preview-frame";
+      frame.setAttribute("sandbox", "");
+      frame.srcdoc = content;
+      preview.append(frame);
+      status.textContent = formatLabel(format);
+      return;
+    }
+
     if (format === "json") {
       const pre = document.createElement("pre");
       try {
@@ -176,7 +188,7 @@ function enhanceTextarea(textarea) {
 }
 
 function languageExtension(format) {
-  if (format === "html") {
+  if (format === "html" || format === "svg") {
     return html();
   }
   if (format === "json") {
@@ -189,7 +201,7 @@ function languageExtension(format) {
 }
 
 function detectFormat({ explicit, fileName, content }) {
-  if (["markdown", "html", "json", "text"].includes(explicit)) {
+  if (SUPPORTED_FORMATS.includes(explicit)) {
     return explicit;
   }
 
@@ -203,8 +215,29 @@ function detectFormat({ explicit, fileName, content }) {
   if (lowerName.endsWith(".json")) {
     return "json";
   }
+  if (lowerName.endsWith(".svg")) {
+    return "svg";
+  }
+  if (lowerName.endsWith(".mmd") || lowerName.endsWith(".mermaid")) {
+    return "mermaid";
+  }
+  if (lowerName.endsWith(".jsx") || lowerName.endsWith(".tsx")) {
+    return "react";
+  }
+  if (/\.(js|ts|py|rb|go|rs|java|c|cc|cpp|cs|php|swift|kt|sh|bash|zsh)$/.test(lowerName)) {
+    return "code";
+  }
 
   const trimmed = String(content || "").trimStart();
+  if (/^(?:<\?xml[\s\S]*?\?>\s*)?<svg[\s>]/i.test(trimmed)) {
+    return "svg";
+  }
+  if (/^(graph|flowchart|sequenceDiagram|classDiagram|stateDiagram|stateDiagram-v2|erDiagram|gantt|pie|mindmap|journey)\b/m.test(trimmed)) {
+    return "mermaid";
+  }
+  if (/\b(import\s+React|from\s+['"]react['"]|export\s+default\s+function|export\s+default\s+\()/m.test(trimmed) || /<[A-Z][A-Za-z0-9]*[\s/>]/.test(trimmed)) {
+    return "react";
+  }
   if (trimmed.startsWith("<!doctype") || trimmed.startsWith("<html") || trimmed.startsWith("<")) {
     return "html";
   }

package/src/client/viewer.js

@@ -0,0 +1,67 @@
+import { EditorView, basicSetup } from "codemirror";
+import { EditorState } from "@codemirror/state";
+import { javascript } from "@codemirror/lang-javascript";
+import { html } from "@codemirror/lang-html";
+import { json } from "@codemirror/lang-json";
+import { markdown } from "@codemirror/lang-markdown";
+
+const viewerTheme = EditorView.theme({
+  "&": {
+    minHeight: "50vh"
+  },
+  ".cm-content": {
+    minHeight: "50vh"
+  },
+  ".cm-scroller": {
+    overflow: "auto"
+  }
+});
+
+for (const container of document.querySelectorAll("[data-artifacty-code-viewer]")) {
+  enhanceCodeViewer(container);
+}
+
+function enhanceCodeViewer(container) {
+  const source = container.querySelector("textarea")?.value || "";
+  const fallback = container.querySelector(".artifact-code-fallback");
+  const language = container.dataset.language || "";
+
+  const mount = document.createElement("div");
+  mount.className = "artifact-codemirror-mount";
+  container.append(mount);
+
+  new EditorView({
+    doc: source,
+    parent: mount,
+    extensions: [
+      basicSetup,
+      EditorState.readOnly.of(true),
+      EditorView.editable.of(false),
+      EditorView.lineWrapping,
+      viewerTheme,
+      languageExtension(language)
+    ]
+  });
+
+  fallback?.remove();
+}
+
+function languageExtension(language) {
+  const normalized = String(language || "").trim().toLowerCase();
+  if (["js", "javascript", "jsx"].includes(normalized)) {
+    return javascript({ jsx: true });
+  }
+  if (["ts", "typescript", "tsx"].includes(normalized)) {
+    return javascript({ typescript: true, jsx: normalized === "tsx" });
+  }
+  if (["html", "xml", "svg"].includes(normalized)) {
+    return html();
+  }
+  if (normalized === "json") {
+    return json();
+  }
+  if (["md", "markdown"].includes(normalized)) {
+    return markdown();
+  }
+  return [];
+}

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.
+  }
+}