artifacty 0.10.6 → 0.10.8

package/README.md

@@ -92,6 +92,10 @@ artifacty serve --host 10.0.0.50 --share-mode team --api-token "$ARTIFACTY_BOOTS
 artifacty install all --mcp-url http://10.0.0.50:8787/mcp --api-token "$ARTIFACTY_PERSONAL_TOKEN"
 ```
 
+When running the central server as a Linux `systemctl --user` service, enable
+lingering for the service account so Artifacty stays up after logout:
+`sudo loginctl enable-linger $USER`.
+
 Administrators can create users individually at `/admin/users` or import them
 from CSV. Use `email,name,role,password,password_reset_required` headers. If
 `password` is empty, Artifacty generates a temporary password, shows it once in
@@ -325,6 +329,7 @@ Schema and storage:
 - Bundle artifacts store multiple files or base64 assets as portable JSON.
 - Supported formats are `html`, `markdown`, `text`, `json`, `code`, `svg`, `mermaid`, `react`, `sarif`, `csv`, `image`, and `video`.
 - Native create/import paths infer `html` from HTML documents or fragments when no explicit format is supplied.
+- `sourceAgent` is canonicalized before storage. Aliases such as `claude-code`, `Claude Code`, `github-copilot`, and `gemini-cli` are stored as `claude`, `copilot`, and `gemini`; legacy `unknown` rows are backfilled only when version metadata, audit data, or source-agent tags provide a known agent.
 - Diagram, component, source snippet, analysis report, table, and media assets use `diagram`, `component`, `snippet`, `analysis-report`, `table`, and `asset` artifact types.
 - Copilot/Cursor examples cover PR reviews, screenshots, demo recordings, and visual evidence bundles.
 - See [docs/artifact-schema-v1.md](docs/artifact-schema-v1.md).

package/docs/artifact-schema-v1.md

@@ -50,6 +50,11 @@ Artifacty store. For authenticated central servers this is the personal token
 owner's email; `publisherName` and `publisherUserId` are included when the
 server can map the request to a local user record. Legacy artifacts are
 best-effort backfilled from the first `create` or `import` audit actor.
+Known source-agent aliases are canonicalized before storage. For example,
+`claude-code`, `Claude Code`, and `anthropic` become `claude`;
+`github-copilot` becomes `copilot`; and `gemini-cli` becomes `gemini`.
+Existing `unknown` rows are upgraded only when version metadata, audit data, or
+source-agent tags provide one of the known agent identities.
 
 ## Version Record
 

package/docs/central-team-deployment-design.md

@@ -134,6 +134,19 @@ proxy, keep `ARTIFACTY_ENABLE_REACT_RENDERER` disabled unless the team trusts
 all artifact authors, and store `ARTIFACTY_HOME` on local server disk with
 regular backups.
 
+For Linux user-service deployments, enable systemd lingering for the service
+account:
+
+```bash
+sudo loginctl enable-linger artifacty
+loginctl show-user artifacty -p Linger
+```
+
+Use the actual service account name. Without lingering, `systemctl --user`
+services are tied to the user's login manager and can stop after logout, making
+the central dashboard and `/mcp` endpoint unavailable until that user logs in
+again. A system-level unit is another valid option for central servers.
+
 The central server exposes `/mcp` only when explicitly enabled. This keeps the
 local browser/API server behavior unchanged while making team MCP exposure an
 intentional operating mode.

package/docs/integrations.md

@@ -321,7 +321,7 @@ Supported converter inputs:
 - Gemini: `returnDisplay`, `llmContent`, text blocks, or local markdown/text/json files.
 - Generic: file extension, content type, HTML doctype/fragments, JSON shape, media data URLs, and markdown headings are used to infer format and title. Generic `text/plain` uploads are upgraded to a more specific format, such as `html`, when filename or content makes that clear.
 
-The converter adds `imported` and source-agent tags, preserves the raw content as an immutable Artifacty version, and records source details under `metadata.artifactyImport`.
+The converter canonicalizes source-agent aliases, adds `imported` and source-agent tags, preserves the raw content as an immutable Artifacty version, and records source details under `metadata.artifactyImport`. For example, `claude-code` and `Claude Code` are stored as `claude`.
 
 Fixture examples for Copilot/Cursor PR review, screenshot, demo recording, and
 visual evidence bundle live under `test/fixtures/` and are covered by converter
@@ -393,9 +393,11 @@ The generated service runs `src/server.js` with explicit `--host` and `--home` a
 Activation is still delegated to the OS service manager:
 
 - macOS: `launchctl load ~/Library/LaunchAgents/com.artifacty.server.plist`
-- Linux: `systemctl --user enable --now com.artifacty.server.service`
+- Linux: `sudo loginctl enable-linger $USER`, then `systemctl --user enable --now com.artifacty.server.service`
 - Windows: run the generated PowerShell script, which registers and starts the `ArtifactyServer` scheduled task.
 
+On Linux central servers, user services stop when the user's systemd manager exits unless lingering is enabled. Verify durable operation with `loginctl show-user $USER -p Linger`; it should report `Linger=yes`. Without lingering, Artifacty may be unavailable after logout and appear to recover only after the user logs back in.
+
 For background services, prefer a stable `ARTIFACTY_API_TOKEN` or `--api-token` value. `serve --generate-token` is intended for temporary interactive sessions; the parent CLI returns the generated token in JSON.
 
 ## Backup and Audit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "artifacty",
-  "version": "0.10.6",
+  "version": "0.10.8",
   "description": "Local artifact exchange for heterogeneous LLM agents via HTTP and MCP.",
   "type": "module",
   "keywords": [

package/src/lib/agents.js

@@ -0,0 +1,53 @@
+export const KNOWN_SOURCE_AGENTS = new Set([
+  "artifacty",
+  "claude",
+  "codex",
+  "copilot",
+  "cursor",
+  "gemini",
+  "generic",
+  "mcp",
+  "unknown"
+]);
+
+const SOURCE_AGENT_ALIASES = new Map([
+  ["anthropic", "claude"],
+  ["claude-ai", "claude"],
+  ["claude-code", "claude"],
+  ["claude-code-cli", "claude"],
+  ["claude_cli", "claude"],
+  ["github-copilot", "copilot"],
+  ["copilot-chat", "copilot"],
+  ["vscode-copilot", "copilot"],
+  ["vs-code-copilot", "copilot"],
+  ["cursor-ai", "cursor"],
+  ["gemini-cli", "gemini"],
+  ["google", "gemini"],
+  ["openai", "codex"],
+  ["openai-codex", "codex"],
+  ["codex-cli", "codex"],
+  ["chatgpt", "codex"]
+]);
+
+export function normalizeSourceAgent(value, options = {}) {
+  const defaultValue = options.defaultValue ?? "unknown";
+  const allowAuto = options.allowAuto === true;
+  const normalized = String(value ?? "").trim().toLowerCase();
+  if (!normalized) {
+    return defaultValue;
+  }
+  if (normalized === "auto") {
+    return allowAuto ? "auto" : defaultValue;
+  }
+  const slug = normalized.replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "");
+  const canonical = SOURCE_AGENT_ALIASES.get(normalized) || SOURCE_AGENT_ALIASES.get(slug) || slug;
+  if (KNOWN_SOURCE_AGENTS.has(canonical)) {
+    return canonical;
+  }
+  return canonical || defaultValue;
+}
+
+export function isUnknownSourceAgent(value) {
+  const normalized = normalizeSourceAgent(value, { defaultValue: "unknown" });
+  return normalized === "unknown" || normalized === "generic" || normalized === "auto";
+}

package/src/lib/converters.js

@@ -1,9 +1,9 @@
 import path from "node:path";
 import { createHash } from "node:crypto";
+import { normalizeSourceAgent } from "./agents.js";
 import { ARTIFACT_TYPES, contentTypeForFormat, normalizeFormat } from "./storage.js";
 
 const CONTINUATION_AGENTS = new Set(["codex", "copilot", "cursor"]);
-const KNOWN_AGENTS = new Set(["auto", "artifacty", "claude", "codex", "copilot", "cursor", "gemini", "generic"]);
 
 export function convertAgentArtifact(input = {}) {
   const originalAgent = normalizeAgent(input.agent || input.sourceAgent || input.source_agent || "auto");
@@ -28,8 +28,11 @@ export function convertAgentArtifact(input = {}) {
   if (media) {
     content = media.content;
   }
-  const sourceAgent = optionalString(input.sourceAgent || input.source_agent || decoded.sourceAgent) ||
-    (originalAgent === "auto" ? detectAgent(parsed, fileName) : originalAgent);
+  const explicitSourceAgent = optionalString(input.sourceAgent || input.source_agent || decoded.sourceAgent);
+  const detectedSourceAgent = originalAgent === "auto" ? detectAgent(parsed, fileName) : originalAgent;
+  const sourceAgent = explicitSourceAgent
+    ? normalizeAgent(explicitSourceAgent)
+    : normalizeAgent(detectedSourceAgent || "unknown");
 
   const title =
     optionalString(input.title) ||
@@ -1387,29 +1390,10 @@ function cleanTitle(value) {
 }
 
 function normalizeAgent(value) {
-  const normalized = optionalString(value).toLowerCase();
-  if (!normalized) {
-    return "auto";
-  }
-  if (normalized === "claude-code" || normalized === "anthropic") {
-    return "claude";
-  }
-  if (normalized === "gemini-cli" || normalized === "google") {
-    return "gemini";
-  }
-  if (normalized === "github-copilot" || normalized === "copilot-chat" || normalized === "vscode-copilot" || normalized === "vs-code-copilot") {
-    return "copilot";
-  }
-  if (normalized === "cursor-ai") {
-    return "cursor";
-  }
-  if (normalized === "openai" || normalized === "chatgpt") {
-    return "codex";
-  }
-  if (KNOWN_AGENTS.has(normalized)) {
-    return normalized;
-  }
-  return normalized.replace(/[^a-z0-9-]+/g, "-") || "generic";
+  return normalizeSourceAgent(value, {
+    defaultValue: "auto",
+    allowAuto: true
+  });
 }
 
 function normalizeTags(tags) {

package/src/lib/service.js

@@ -184,9 +184,11 @@ function definitionForPlatform(platform, options = {}, renderOnly) {
       path: servicePath(platform, options),
       content: createSystemdUserUnit(options),
       nextSteps: [
+        "sudo loginctl enable-linger $USER",
         "systemctl --user daemon-reload",
         `systemctl --user enable --now ${path.basename(servicePath(platform, options))}`,
         `systemctl --user status ${path.basename(servicePath(platform, options))}`,
+        "loginctl show-user $USER -p Linger",
         `journalctl --user -u ${path.basename(servicePath(platform, options))} -f`,
         `systemctl --user disable --now ${path.basename(servicePath(platform, options))}`
       ],

package/src/lib/storage.js

@@ -4,11 +4,13 @@ import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 import { DatabaseSync } from "node:sqlite";
+import { isUnknownSourceAgent, normalizeSourceAgent } from "./agents.js";
 import { assertNoSecrets, securityConfig } from "./security.js";
 
 export const STORE_VERSION = 4;
 export const ARTIFACT_SCHEMA_VERSION = 1;
 export const MAX_ARTIFACT_BYTES = 16 * 1024 * 1024;
+const SOURCE_AGENT_NORMALIZATION_VERSION = "1";
 export const USER_ROLES = ["admin", "user"];
 export const ARTIFACT_FORMATS = [
   "html",
@@ -122,6 +124,11 @@ export async function writeIndex(store, index) {
           insertVersionRecord(db, artifact.id, version);
         }
       }
+      normalizeStoredSourceAgents(db, store, {
+        force: true,
+        inTransaction: true,
+        rebuildSearch: false
+      });
       rebuildSearchIndexInDb(db, store);
     });
   } finally {
@@ -182,7 +189,11 @@ export async function createArtifact(store = createStore(), input = {}) {
 export async function updateArtifact(store = createStore(), id, input = {}) {
   const secretScan = assertNoSecrets(input, securityConfig());
   input = withSecretScan(input, secretScan);
-  const normalized = normalizeArtifactInput(input, { requireContent: true, requireTitle: false });
+  const normalized = normalizeArtifactInput(input, {
+    requireContent: true,
+    requireTitle: false,
+    defaultSourceAgent: ""
+  });
   const db = openDatabase(store);
 
   try {
@@ -252,7 +263,11 @@ export async function updateArtifact(store = createStore(), id, input = {}) {
 export async function replaceArtifactVersion(store = createStore(), id, versionNumber, input = {}) {
   const secretScan = assertNoSecrets(input, securityConfig());
   input = withSecretScan(input, secretScan);
-  const normalized = normalizeArtifactInput(input, { requireContent: true, requireTitle: false });
+  const normalized = normalizeArtifactInput(input, {
+    requireContent: true,
+    requireTitle: false,
+    defaultSourceAgent: ""
+  });
   const targetVersion = Number(versionNumber);
   if (!Number.isInteger(targetVersion) || targetVersion < 1) {
     throw Object.assign(new Error(`Invalid artifact version: ${versionNumber}`), {
@@ -467,7 +482,7 @@ export async function listArtifactsPage(store = createStore(), filters = {}) {
   const query = normalizeOptionalString(filters.query);
   const normalizedQuery = query.toLowerCase();
   const tag = normalizeOptionalString(filters.tag).toLowerCase();
-  const sourceAgent = normalizeOptionalString(filters.sourceAgent).toLowerCase();
+  const sourceAgent = normalizeSourceAgent(filters.sourceAgent, { defaultValue: "" }).toLowerCase();
 
   try {
     if (query && searchIndexAvailable(db)) {
@@ -1250,6 +1265,7 @@ function openDatabase(store) {
   `);
   initializeSchema(db);
   migrateJsonIndex(db, store);
+  normalizeStoredSourceAgents(db, store);
   syncSearchIndexIfEmpty(db, store);
   return db;
 }
@@ -1492,6 +1508,140 @@ function migrateJsonIndex(db, store) {
   });
 }
 
+function metaValue(db, key) {
+  return db.prepare("SELECT value FROM meta WHERE key = ?").get(key)?.value || "";
+}
+
+const INFERABLE_SOURCE_AGENTS = new Set(["claude", "codex", "copilot", "cursor", "gemini"]);
+
+function normalizeStoredSourceAgents(db, store, options = {}) {
+  if (!options.force && metaValue(db, "source_agent_normalized_version") === SOURCE_AGENT_NORMALIZATION_VERSION) {
+    return;
+  }
+
+  const run = () => normalizeStoredSourceAgentsInDb(db, store, options);
+  if (options.inTransaction) {
+    run();
+  } else {
+    transaction(db, run);
+  }
+}
+
+function normalizeStoredSourceAgentsInDb(db, store, options = {}) {
+  const rows = db.prepare(`
+    SELECT id, source_agent, tags_json
+    FROM artifacts
+  `).all();
+  const updateArtifact = db.prepare("UPDATE artifacts SET source_agent = ?, tags_json = ? WHERE id = ?");
+  let changed = false;
+
+  for (const row of rows) {
+    const normalized = normalizeSourceAgent(row.source_agent, { defaultValue: "unknown" });
+    const inferred = isUnknownSourceAgent(normalized)
+      ? inferStoredSourceAgent(db, row)
+      : normalized;
+    const nextSourceAgent = inferred || normalized;
+    const nextTags = normalizeStoredSourceTags(row.tags_json, nextSourceAgent);
+    if (nextSourceAgent !== row.source_agent || nextTags !== row.tags_json) {
+      updateArtifact.run(nextSourceAgent, nextTags, row.id);
+      changed = true;
+    }
+  }
+
+  const auditRows = db.prepare(`
+    SELECT id, source_agent
+    FROM audit_log
+    WHERE source_agent IS NOT NULL
+      AND TRIM(source_agent) != ''
+  `).all();
+  const updateAudit = db.prepare("UPDATE audit_log SET source_agent = ? WHERE id = ?");
+  for (const row of auditRows) {
+    const normalized = normalizeSourceAgent(row.source_agent, { defaultValue: "" });
+    if (normalized && normalized !== row.source_agent) {
+      updateAudit.run(normalized, row.id);
+      changed = true;
+    }
+  }
+
+  db.prepare("INSERT OR REPLACE INTO meta (key, value) VALUES ('source_agent_normalized_version', ?)").run(SOURCE_AGENT_NORMALIZATION_VERSION);
+
+  if (changed && options.rebuildSearch !== false) {
+    rebuildSearchIndexInDb(db, store);
+  }
+}
+
+function inferStoredSourceAgent(db, artifactRow) {
+  const tagCandidate = firstInferableSourceAgent(parseJson(artifactRow.tags_json, []));
+  if (tagCandidate) {
+    return tagCandidate;
+  }
+
+  const versionRows = db.prepare(`
+    SELECT metadata_json
+    FROM artifact_versions
+    WHERE artifact_id = ?
+    ORDER BY version DESC
+  `).all(artifactRow.id);
+  for (const row of versionRows) {
+    const metadata = parseJson(row.metadata_json, {});
+    const candidate = firstInferableSourceAgent([
+      metadata.sourceAgent,
+      metadata.source_agent,
+      metadata.agent,
+      metadata.artifactyImport?.sourceAgent,
+      metadata.artifactyImport?.originalAgent
+    ]);
+    if (candidate) {
+      return candidate;
+    }
+  }
+
+  const auditRows = db.prepare(`
+    SELECT source_agent
+    FROM audit_log
+    WHERE artifact_id = ?
+      AND source_agent IS NOT NULL
+      AND TRIM(source_agent) != ''
+    ORDER BY created_at DESC
+  `).all(artifactRow.id);
+  return firstInferableSourceAgent(auditRows.map((row) => row.source_agent));
+}
+
+function normalizeStoredSourceTags(tagsJson, sourceAgent) {
+  const tags = parseJson(tagsJson, []);
+  if (!Array.isArray(tags)) {
+    return JSON.stringify([]);
+  }
+  const normalizedTags = [];
+  for (const tag of tags) {
+    const trimmed = normalizeOptionalString(tag);
+    if (!trimmed) {
+      continue;
+    }
+    const canonical = inferableSourceAgent(trimmed);
+    const next = canonical || (trimmed === "unknown" && INFERABLE_SOURCE_AGENTS.has(sourceAgent) ? sourceAgent : trimmed);
+    if (!normalizedTags.includes(next)) {
+      normalizedTags.push(next);
+    }
+  }
+  return JSON.stringify(normalizedTags);
+}
+
+function firstInferableSourceAgent(values) {
+  for (const value of values || []) {
+    const candidate = inferableSourceAgent(value);
+    if (candidate) {
+      return candidate;
+    }
+  }
+  return "";
+}
+
+function inferableSourceAgent(value) {
+  const normalized = normalizeSourceAgent(value, { defaultValue: "" });
+  return INFERABLE_SOURCE_AGENTS.has(normalized) ? normalized : "";
+}
+
 function ensureSearchTable(db) {
   try {
     const existing = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table' AND name = 'artifact_search'").get();
@@ -1715,7 +1865,7 @@ function insertArtifactRecord(db, artifact) {
     artifact.title,
     normalizeArtifactType(artifact.artifactType || artifact.artifact_type || "document"),
     normalizeSchemaVersion(artifact.schemaVersion || artifact.schema_version),
-    artifact.sourceAgent || artifact.source_agent || "unknown",
+    normalizeSourceAgent(artifact.sourceAgent || artifact.source_agent, { defaultValue: "unknown" }),
     normalizeOptionalString(artifact.publisherId || artifact.publisher_id) || null,
     normalizeOptionalString(artifact.publisherName || artifact.publisher_name) || null,
     normalizeOptionalString(artifact.publisherUserId || artifact.publisher_user_id) || null,
@@ -1925,7 +2075,9 @@ function normalizeArtifactInput(input, options) {
     contentType: normalizeOptionalString(input.contentType),
     artifactType: normalizeArtifactType(input.artifactType || input.artifact_type || inferArtifactType(input)),
     schemaVersion: normalizeSchemaVersion(input.schemaVersion || input.schema_version),
-    sourceAgent: normalizeOptionalString(input.sourceAgent || input.source_agent || input.agent) || "unknown",
+    sourceAgent: normalizeSourceAgent(input.sourceAgent || input.source_agent || input.agent, {
+      defaultValue: options.defaultSourceAgent ?? "unknown"
+    }),
     tags: normalizeTags(input.tags),
     metadata: normalizeMetadata(input.metadata)
   };