artifacty 0.7.0 → 0.9.0

package/src/lib/doctor.js

@@ -0,0 +1,214 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { arch, platform } from "node:os";
+import { backgroundStatus } from "./background.js";
+import { checkMcpTools } from "./check.js";
+import { securityConfig, validateServerExposure, exposureWarning } from "./security.js";
+import { serviceCommand } from "./service.js";
+import { checkStoreIntegrity, createStore } from "./storage.js";
+
+const MIN_NODE_VERSION = "22.5.0";
+
+export async function runDoctor(options = {}) {
+  const packageRoot = path.resolve(options.packageRoot || process.cwd());
+  const store = createStore({ home: options.home });
+  const checks = [];
+
+  await collect(checks, "runtime", () => runtimeCheck(packageRoot));
+  await collect(checks, "security", () => securityCheck(options));
+  await collect(checks, "storage", () => storageCheck(store));
+  await collect(checks, "server", () => serverCheck(store));
+  await collect(checks, "service", () => serviceCheck(options));
+  if (options.skipMcp) {
+    checks.push({
+      name: "mcp",
+      status: "skip",
+      message: "MCP discovery skipped by --skip-mcp"
+    });
+  } else {
+    await collect(checks, "mcp", () => mcpCheck(packageRoot, options));
+  }
+
+  const failures = checks.filter((check) => check.status === "fail");
+  const warnings = checks.filter((check) => check.status === "warn");
+
+  return {
+    ok: failures.length === 0,
+    checkedAt: new Date().toISOString(),
+    version: await packageVersion(packageRoot),
+    home: store.home,
+    platform: process.platform,
+    checks,
+    failures: failures.map(({ name, message }) => ({ name, message })),
+    warnings: warnings.map(({ name, message }) => ({ name, message }))
+  };
+}
+
+async function collect(checks, name, fn) {
+  try {
+    checks.push({ name, ...(await fn()) });
+  } catch (error) {
+    checks.push({
+      name,
+      status: "fail",
+      message: error.message,
+      error: {
+        name: error.name,
+        code: error.code
+      }
+    });
+  }
+}
+
+async function runtimeCheck(packageRoot) {
+  const version = await packageVersion(packageRoot);
+  const supported = compareVersions(process.versions.node, MIN_NODE_VERSION) >= 0;
+  return {
+    status: supported ? "pass" : "fail",
+    message: supported
+      ? `Node ${process.versions.node} satisfies >=${MIN_NODE_VERSION}`
+      : `Node ${process.versions.node} is below required >=${MIN_NODE_VERSION}`,
+    data: {
+      artifactyVersion: version,
+      nodeVersion: process.versions.node,
+      requiredNodeVersion: `>=${MIN_NODE_VERSION}`,
+      platform: platform(),
+      arch: arch()
+    }
+  };
+}
+
+function securityCheck(options = {}) {
+  const host = options.host || process.env.ARTIFACTY_HOST || "127.0.0.1";
+  const config = securityConfig(options);
+  validateServerExposure({ host, config });
+  const warning = exposureWarning({ host, config });
+  if (warning) {
+    return {
+      status: "warn",
+      message: warning,
+      data: {
+        host,
+        shareMode: config.shareMode,
+        hasApiToken: Boolean(config.apiToken)
+      }
+    };
+  }
+  return {
+    status: "pass",
+    message: "Server exposure settings are local-first",
+    data: {
+      host,
+      shareMode: config.shareMode,
+      hasApiToken: Boolean(config.apiToken)
+    }
+  };
+}
+
+async function storageCheck(store) {
+  const integrity = await checkStoreIntegrity(store);
+  return {
+    status: integrity.ok ? "pass" : "fail",
+    message: integrity.ok
+      ? `Store is consistent with ${integrity.artifactCount} artifacts and ${integrity.versionCount} versions`
+      : "Store integrity check found missing, changed, orphaned, or inconsistent files",
+    data: integrity
+  };
+}
+
+async function serverCheck(store) {
+  const status = await backgroundStatus({ home: store.home });
+  if (status.running) {
+    return {
+      status: "pass",
+      message: `Managed server is healthy at ${status.url}`,
+      data: status
+    };
+  }
+  if (status.processRunning || status.pidFileExists) {
+    return {
+      status: "fail",
+      message: "Recorded server process or pid file exists but health check is not passing",
+      data: status
+    };
+  }
+  return {
+    status: "warn",
+    message: "No managed Artifacty server is currently running",
+    data: status
+  };
+}
+
+async function serviceCheck(options = {}) {
+  const definitions = [];
+  for (const action of ["plist", "unit", "task"]) {
+    const result = await serviceCommand(action, {
+      projectDir: options.packageRoot || process.cwd(),
+      serverPath: options.serverPath,
+      host: options.host,
+      port: options.port,
+      home: options.home,
+      apiToken: options.apiToken,
+      shareMode: options.shareMode,
+      allowSecrets: options.allowSecrets,
+      dryRun: true
+    });
+    definitions.push({
+      action,
+      platform: result.platform,
+      path: result.path,
+      contentBytes: Buffer.byteLength(result.content || "", "utf8")
+    });
+  }
+  return {
+    status: "pass",
+    message: "Service definitions render for macOS, Linux, and Windows",
+    data: { definitions }
+  };
+}
+
+async function mcpCheck(packageRoot, options = {}) {
+  const result = await checkMcpTools({
+    projectDir: packageRoot,
+    serverPath: options.serverPath,
+    url: options.url,
+    home: options.home,
+    timeout: options.timeout
+  });
+  return {
+    status: result.ok ? "pass" : "fail",
+    message: result.ok
+      ? `MCP discovery found ${result.toolCount} tools, ${result.resourceCount} resources, and ${result.promptCount} prompts`
+      : "MCP discovery is missing required tools, resources, or prompts",
+    data: result
+  };
+}
+
+async function packageVersion(packageRoot) {
+  const file = path.join(packageRoot, "package.json");
+  const parsed = JSON.parse(await readFile(file, "utf8"));
+  return parsed.version;
+}
+
+function compareVersions(left, right) {
+  const leftParts = versionParts(left);
+  const rightParts = versionParts(right);
+  for (let index = 0; index < Math.max(leftParts.length, rightParts.length); index += 1) {
+    const leftPart = leftParts[index] || 0;
+    const rightPart = rightParts[index] || 0;
+    if (leftPart > rightPart) {
+      return 1;
+    }
+    if (leftPart < rightPart) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+function versionParts(value) {
+  return String(value)
+    .split(".")
+    .map((part) => Number.parseInt(part, 10))
+    .filter((part) => Number.isFinite(part));
+}

package/src/lib/installer.js

@@ -48,6 +48,17 @@ export function createMcpServerConfig(options = {}) {
     env.ARTIFACTY_URL = options.url || process.env.ARTIFACTY_URL;
   }
 
+  if (options.mcpUrl || process.env.ARTIFACTY_MCP_URL) {
+    env.ARTIFACTY_MCP_MODE = normalizeMcpMode(options.transport || "bridge");
+    env.ARTIFACTY_MCP_URL = normalizeMcpEndpoint(options.mcpUrl || process.env.ARTIFACTY_MCP_URL);
+  } else if (options.transport || process.env.ARTIFACTY_MCP_MODE) {
+    env.ARTIFACTY_MCP_MODE = normalizeMcpMode(options.transport || process.env.ARTIFACTY_MCP_MODE);
+  }
+
+  if (options.apiToken || process.env.ARTIFACTY_API_TOKEN) {
+    env.ARTIFACTY_API_TOKEN = options.apiToken || process.env.ARTIFACTY_API_TOKEN;
+  }
+
   if (options.home || process.env.ARTIFACTY_HOME) {
     env.ARTIFACTY_HOME = path.resolve(options.home || process.env.ARTIFACTY_HOME);
   }
@@ -241,6 +252,26 @@ function normalizeTimeoutMs(value) {
   return Number.isFinite(timeout) && timeout > 0 ? timeout : DEFAULT_MCP_TIMEOUT_MS;
 }
 
+function normalizeMcpMode(value) {
+  const mode = String(value || "bridge").trim().toLowerCase();
+  if (mode === "remote") {
+    return "bridge";
+  }
+  if (!["local", "bridge"].includes(mode)) {
+    throw new Error("MCP transport must be local or bridge");
+  }
+  return mode;
+}
+
+function normalizeMcpEndpoint(value) {
+  const parsed = new URL(value);
+  const pathname = parsed.pathname.replace(/\/+$/, "");
+  parsed.pathname = pathname || "/mcp";
+  parsed.search = "";
+  parsed.hash = "";
+  return parsed.toString();
+}
+
 function quoteTomlString(value) {
   return JSON.stringify(String(value));
 }

package/src/lib/render.js

@@ -2,7 +2,7 @@ import { EDITOR_CLIENT_PATH, VIEWER_CLIENT_PATH, editorImportMapJson } from "./e
 import { createI18n, DEFAULT_LOCALE, editorMessages, localizedHref, switchLocaleHref } from "./i18n.js";
 import { ARTIFACT_FORMATS, ARTIFACT_TYPES } from "./storage.js";
 
-export function renderDashboard({ artifacts, baseUrl, filters = {}, pagination, locale = DEFAULT_LOCALE, currentPath = "/" }) {
+export function renderDashboard({ artifacts, baseUrl, filters = {}, pagination, locale = DEFAULT_LOCALE, currentPath = "/", user = null }) {
   const view = viewContext(locale, currentPath);
   const total = pagination?.total ?? artifacts.length;
   const start = artifacts.length ? (pagination?.offset ?? 0) + 1 : 0;
@@ -48,6 +48,7 @@ export function renderDashboard({ artifacts, baseUrl, filters = {}, pagination,
           <a href="${view.href("/new")}">${view.text("nav.new")}</a>
           <a href="${view.href("/import")}">${view.text("nav.import")}</a>
           <a href="/api/artifacts">${view.text("nav.api")}</a>
+          ${authNav(user)}
           ${languageSwitcher(view)}
         </nav>
       </header>
@@ -249,6 +250,170 @@ export function renderImportArtifactPage({ baseUrl, authToken = "", locale = DEF
   });
 }
 
+export function renderLoginPage({ baseUrl, setup = false, error = "", locale = DEFAULT_LOCALE, currentPath = "/login" }) {
+  const view = viewContext(locale, currentPath);
+  const title = setup ? "Create admin account" : "Sign in";
+  return pageShell({
+    title,
+    body: `
+      <header class="topbar">
+        <div>
+          <h1>${escapeHtml(title)}</h1>
+          <p>${escapeHtml(baseUrl)}</p>
+        </div>
+        <nav>
+          <a href="${view.href("/")}">${view.text("nav.index")}</a>
+          ${languageSwitcher(view)}
+        </nav>
+      </header>
+      <main class="artifact-editor auth-panel">
+        ${error ? `<p class="auth-error">${escapeHtml(error)}</p>` : ""}
+        ${setup ? `<p class="muted">No users exist yet. The first account becomes an administrator.</p>` : ""}
+        <form class="editor-form auth-form" method="post" action="/login">
+          <section class="editor-fields">
+            <label class="field">
+              <span>Email</span>
+              <input type="email" name="email" autocomplete="username" required>
+            </label>
+            ${setup ? `<label class="field">
+              <span>Name</span>
+              <input name="name" autocomplete="name">
+            </label>` : ""}
+            <label class="field">
+              <span>Password</span>
+              <input type="password" name="password" autocomplete="${setup ? "new-password" : "current-password"}" minlength="8" required>
+            </label>
+          </section>
+          <footer class="editor-actions">
+            <button type="submit">${setup ? "Create admin" : "Sign in"}</button>
+          </footer>
+        </form>
+      </main>
+    `,
+    locale: view.locale
+  });
+}
+
+export function renderAccountPage({ baseUrl, user, tokens = [], createdToken = "", locale = DEFAULT_LOCALE, currentPath = "/account" }) {
+  const view = viewContext(locale, currentPath);
+  const rows = tokens.map((token) => `
+    <tr>
+      <td>${escapeHtml(token.name)}</td>
+      <td>${escapeHtml(token.createdAt)}</td>
+      <td>${token.lastUsedAt ? escapeHtml(token.lastUsedAt) : "Never"}</td>
+      <td>${token.revokedAt ? escapeHtml(token.revokedAt) : "Active"}</td>
+      <td>
+        ${token.revokedAt ? "" : `<form method="post" action="/account/tokens/${encodeURIComponent(token.id)}/revoke">
+          <button type="submit">Revoke</button>
+        </form>`}
+      </td>
+    </tr>
+  `).join("");
+
+  return pageShell({
+    title: "Account",
+    body: `
+      <header class="topbar">
+        <div>
+          <h1>Account</h1>
+          <p>${escapeHtml(user.email)} · ${escapeHtml(user.role)} · ${escapeHtml(baseUrl)}</p>
+        </div>
+        <nav>
+          <a href="${view.href("/")}">${view.text("nav.index")}</a>
+          ${user.role === "admin" ? `<a href="/admin/users">Users</a>` : ""}
+          <form class="nav-form" method="post" action="/logout"><button type="submit">Sign out</button></form>
+          ${languageSwitcher(view)}
+        </nav>
+      </header>
+      <main class="artifact-view">
+        ${createdToken ? `<section class="token-once">
+          <h2>New API token</h2>
+          <p>Copy this token now. Artifacty stores only its hash and cannot show it again.</p>
+          <pre class="artifact-code"><code>${escapeHtml(createdToken)}</code></pre>
+        </section>` : ""}
+        <section class="meta-card">
+          <h2>Profile</h2>
+          <p><strong>${escapeHtml(user.name)}</strong></p>
+          <p>${escapeHtml(user.email)}</p>
+          <p>Role: ${escapeHtml(user.role)}</p>
+        </section>
+        <section class="meta-card">
+          <h2>Create API token</h2>
+          <form class="inline-action" method="post" action="/account/tokens">
+            <input name="name" placeholder="Token name" autocomplete="off" required>
+            <button type="submit">Create token</button>
+          </form>
+        </section>
+        <section class="meta-card">
+          <h2>API tokens</h2>
+          <table class="data-table">
+            <thead><tr><th>Name</th><th>Created</th><th>Last used</th><th>Status</th><th></th></tr></thead>
+            <tbody>${rows || `<tr><td colspan="5">No API tokens.</td></tr>`}</tbody>
+          </table>
+        </section>
+      </main>
+    `,
+    locale: view.locale
+  });
+}
+
+export function renderAdminUsersPage({ baseUrl, user, users = [], locale = DEFAULT_LOCALE, currentPath = "/admin/users" }) {
+  const view = viewContext(locale, currentPath);
+  const rows = users.map((item) => `
+    <tr>
+      <td>${escapeHtml(item.email)}</td>
+      <td>${escapeHtml(item.name)}</td>
+      <td>${escapeHtml(item.role)}</td>
+      <td>${item.active ? "Active" : "Disabled"}</td>
+      <td>${escapeHtml(item.createdAt)}</td>
+      <td>
+        ${item.id === user.id ? "" : `<form method="post" action="/admin/users/${encodeURIComponent(item.id)}/${item.active ? "disable" : "enable"}">
+          <button type="submit">${item.active ? "Disable" : "Enable"}</button>
+        </form>`}
+      </td>
+    </tr>
+  `).join("");
+
+  return pageShell({
+    title: "Users",
+    body: `
+      <header class="topbar">
+        <div>
+          <h1>Users</h1>
+          <p>${escapeHtml(baseUrl)}</p>
+        </div>
+        <nav>
+          <a href="${view.href("/")}">${view.text("nav.index")}</a>
+          <a href="/account">Account</a>
+          ${languageSwitcher(view)}
+        </nav>
+      </header>
+      <main class="artifact-view">
+        <section class="meta-card">
+          <h2>Create user</h2>
+          <form class="editor-form auth-form" method="post" action="/admin/users">
+            <section class="editor-fields">
+              <label class="field"><span>Email</span><input type="email" name="email" required></label>
+              <label class="field"><span>Name</span><input name="name"></label>
+              <label class="field"><span>Role</span><select name="role"><option value="user">user</option><option value="admin">admin</option></select></label>
+              <label class="field"><span>Password</span><input type="password" name="password" minlength="8" required></label>
+            </section>
+            <footer class="editor-actions"><button type="submit">Create user</button></footer>
+          </form>
+        </section>
+        <section class="meta-card">
+          <h2>Existing users</h2>
+          <table class="data-table">
+            <thead><tr><th>Email</th><th>Name</th><th>Role</th><th>Status</th><th>Created</th><th></th></tr></thead>
+            <tbody>${rows}</tbody>
+          </table>
+        </section>
+      </main>
+    `,
+    locale: view.locale
+  });
+}
+
 export function renderArtifactPage({ artifact, version, content, baseUrl, authToken = "", locale = DEFAULT_LOCALE, currentPath = "/" }) {
   const view = viewContext(locale, currentPath);
   const versionLinks = artifact.versions
@@ -726,6 +891,25 @@ export function pageShell({ title, body, head = "", afterBody = "", locale = DEF
     .inline-action {
       margin-bottom: 12px;
     }
+    .nav-form {
+      display: inline-flex;
+      margin: 0;
+    }
+    .nav-form button {
+      min-height: 0;
+      padding: 0;
+      border: 0;
+      background: transparent;
+      color: inherit;
+      font: inherit;
+      font-weight: inherit;
+    }
+    .nav-form button:hover {
+      background: transparent;
+      border: 0;
+      color: var(--text);
+      text-decoration: underline;
+    }
     .diff-form {
       grid-template-columns: 160px 160px auto;
       width: fit-content;
@@ -788,6 +972,64 @@ export function pageShell({ title, body, head = "", afterBody = "", locale = DEF
       display: grid;
       gap: 16px;
     }
+    .auth-panel {
+      max-width: 720px;
+      margin: 0 auto;
+    }
+    .auth-form .editor-fields {
+      grid-template-columns: minmax(220px, 1fr);
+    }
+    .auth-error,
+    .token-once {
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 12px 14px;
+      background: var(--panel);
+    }
+    .auth-error {
+      color: #991b1b;
+      background: #fef2f2;
+      border-color: #fecaca;
+    }
+    .muted {
+      color: var(--muted);
+    }
+    .meta-card {
+      display: grid;
+      gap: 10px;
+      margin-bottom: 16px;
+      border: 1px solid var(--line);
+      border-radius: 8px;
+      padding: 16px;
+      background: var(--panel);
+    }
+    .meta-card h2,
+    .token-once h2 {
+      margin: 0;
+      font-size: 18px;
+    }
+    .data-table {
+      width: 100%;
+      border-collapse: collapse;
+      font-size: 13px;
+    }
+    .data-table th,
+    .data-table td {
+      padding: 9px 10px;
+      border-bottom: 1px solid var(--line);
+      text-align: left;
+      vertical-align: middle;
+    }
+    .data-table th {
+      color: var(--faint);
+      font-family: var(--mono);
+      font-size: 11.5px;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+    }
+    .data-table form {
+      margin: 0;
+    }
     .editor-fields {
       display: grid;
       grid-template-columns: minmax(220px, 1fr) 180px 180px minmax(160px, 240px);
@@ -1573,6 +1815,13 @@ function languageSwitcher(view) {
   return `<span class="language-switcher">${english}${korean}</span>`;
 }
 
+function authNav(user) {
+  if (!user) {
+    return `<a href="/login">Sign in</a>`;
+  }
+  return `${user.role === "admin" ? `<a href="/admin/users">Users</a>` : ""}<a href="/account">Account</a>`;
+}
+
 export function escapeHtml(value) {
   return String(value)
     .replaceAll("&", "&amp;")

package/src/lib/security.js

@@ -57,6 +57,10 @@ export function requireToken({ request, url, body = {}, config = securityConfig(
   }
 }
 
+export function requestToken({ request, url, body = {} }) {
+  return extractToken({ request, url, body });
+}
+
 export function scanForSecrets(content) {
   const text = String(content ?? "");
   const findings = [];

package/src/lib/service.js

@@ -230,6 +230,7 @@ function serviceConfig(options = {}) {
     apiToken: options.apiToken || "",
     shareMode: options.shareMode || "",
     allowSecrets: Boolean(options.allowSecrets),
+    mcpHttp: Boolean(options.mcpHttp),
     taskName: options.taskName || DEFAULT_TASK_NAME
   };
 }
@@ -251,6 +252,9 @@ function serverArgs(config, options = {}) {
   if (config.allowSecrets) {
     args.push("--allow-secrets");
   }
+  if (config.mcpHttp) {
+    args.push("--mcp-http");
+  }
   if (options.includeApiTokenArg && config.apiToken) {
     args.push("--api-token", config.apiToken);
   }