@artifactly/mcp 0.1.4 → 0.1.6

package/README.md

@@ -23,6 +23,18 @@ npm run build
 
 The MCP package is published as `@artifactly/mcp`.
 
+Codex and other MCP clients can launch the server with either of these forms:
+
+```bash
+npx -y @artifactly/mcp
+```
+
+```bash
+npx -y --package=@artifactly/mcp artifactly-mcp
+```
+
+The package also exposes a human CLI as `artifactly`.
+
 Manual publish from a logged-in maintainer account:
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@artifactly/mcp",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "private": false,
   "files": [
     "bin",
@@ -10,6 +10,7 @@
   ],
   "bin": {
     "artifactly": "bin/artifactly.mjs",
+    "mcp": "bin/artifactly-mcp.mjs",
     "artifactly-mcp": "bin/artifactly-mcp.mjs"
   },
   "scripts": {

package/src/cli/artifactly-cli.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -82,6 +82,26 @@ describe("artifactly CLI", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  it("logs out by removing stored credentials", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-cli-"));
+    const credentialPath = join(dir, "credentials.json");
+    const output: string[] = [];
+    const cli = createArtifactlyCli({
+      credentialPath,
+      stdout: (line) => output.push(line),
+    });
+
+    await cli.run(["login", "--api-key", "art_test_secret", "--email", "agent@example.com"]);
+    expect(existsSync(credentialPath)).toBe(true);
+
+    await cli.run(["logout"]);
+
+    expect(existsSync(credentialPath)).toBe(false);
+    expect(readCredentials(credentialPath)).toBeNull();
+    expect(output.at(-1)).toBe("Logged out of Artifactly.");
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   it("reports the default credential path under the user home", () => {
     expect(getDefaultCredentialPath("/Users/alice")).toBe(
       "/Users/alice/.artifactly/credentials.json",

package/src/cli/artifactly-cli.ts

@@ -1,4 +1,4 @@
-import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 import { createInterface } from "node:readline/promises";
@@ -73,6 +73,10 @@ export function writeCredentials(
   writeFileSync(path, `${JSON.stringify(credentials, null, 2)}\n`, { mode: 0o600 });
 }
 
+export function clearCredentials(path = getDefaultCredentialPath()) {
+  rmSync(path, { force: true });
+}
+
 async function defaultPrompt(question: string) {
   const readline = createInterface({ input, output });
   try {
@@ -166,6 +170,11 @@ export function createArtifactlyCli(options: ArtifactlyCliOptions = {}) {
     stdout(`Workspace: ${credentials.workspace ?? "unknown"}`);
   }
 
+  function logout() {
+    clearCredentials(credentialPath);
+    stdout("Logged out of Artifactly.");
+  }
+
   async function publish(argv: string[]) {
     const credentials = readCredentials(credentialPath);
     if (!credentials) {
@@ -206,10 +215,11 @@ export function createArtifactlyCli(options: ArtifactlyCliOptions = {}) {
     const [command, ...rest] = argv;
     try {
       if (command === "login") return await login(rest);
+      if (command === "logout") return logout();
       if (command === "whoami") return whoami();
       if (command === "publish") return await publish(rest);
       if (command === "mcp") return await mcp(rest);
-      stdout("Usage: artifactly <login|whoami|publish|mcp>");
+      stdout("Usage: artifactly <login|logout|whoami|publish|mcp>");
     } catch (error) {
       const message = error instanceof Error ? error.message : String(error);
       stderr(message);

package/src/mcp/artifactly-mcp-server.test.ts

@@ -11,6 +11,7 @@ describe("Artifactly MCP server packaging", () => {
   it("exposes installable CLI bins for humans and MCP clients", () => {
     expect(packageJson.bin).toEqual({
       artifactly: "bin/artifactly.mjs",
+      mcp: "bin/artifactly-mcp.mjs",
       "artifactly-mcp": "bin/artifactly-mcp.mjs",
     });
     expect(packageJson.dependencies).toHaveProperty("@modelcontextprotocol/sdk");
@@ -41,9 +42,13 @@ describe("Artifactly MCP stdio server helpers", () => {
       "artifactly_auth_status",
       "artifactly_request_login_code",
       "artifactly_verify_login_code",
+      "artifactly_logout",
       "artifactly_publish_markdown",
       "artifactly_list_artifacts",
       "artifactly_get_artifact",
+      "artifactly_update_artifact",
+      "artifactly_delete_artifact",
+      "artifactly_publish_file",
     ]);
   });
 

package/src/mcp/artifactly-mcp-server.ts

@@ -92,6 +92,7 @@ const verifyLoginCodeSchema = z.object({
   email: z.string().email(),
   code: z.string().min(4),
 });
+const logoutSchema = z.object({});
 const publishMarkdownSchema = z.object({
   title: z.string().min(1),
   markdown: z.string().min(1),
@@ -101,14 +102,36 @@ const listArtifactsSchema = z.object({});
 const getArtifactSchema = z.object({
   artifactId: z.string().min(1),
 });
+const updateArtifactSchema = z.object({
+  artifactId: z.string().min(1),
+  title: z.string().min(1).optional(),
+  markdown: z.string().min(1).optional(),
+  content: z.string().min(1).optional(),
+  description: z.string().min(1).optional(),
+  visibility: z.enum(["public", "unlisted", "private", "gated"]).optional(),
+  accessList: z.array(z.string().email()).optional(),
+});
+const deleteArtifactSchema = z.object({
+  artifactId: z.string().min(1),
+});
+const publishFileSchema = z.object({
+  path: z.string().min(1),
+  title: z.string().min(1).optional(),
+  mimeType: z.string().min(1).optional(),
+  visibility: z.enum(["public", "unlisted", "private", "gated"]).optional(),
+});
 
 const toolSchemas = {
   artifactly_auth_status: authStatusSchema,
   artifactly_request_login_code: requestLoginCodeSchema,
   artifactly_verify_login_code: verifyLoginCodeSchema,
+  artifactly_logout: logoutSchema,
   artifactly_publish_markdown: publishMarkdownSchema,
   artifactly_list_artifacts: listArtifactsSchema,
   artifactly_get_artifact: getArtifactSchema,
+  artifactly_update_artifact: updateArtifactSchema,
+  artifactly_delete_artifact: deleteArtifactSchema,
+  artifactly_publish_file: publishFileSchema,
 } as const;
 
 export function createArtifactlyMcpServer() {

package/src/mcp/artifactly-mcp.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
@@ -13,9 +13,13 @@ describe("Artifactly MCP tools", () => {
       "artifactly_auth_status",
       "artifactly_request_login_code",
       "artifactly_verify_login_code",
+      "artifactly_logout",
       "artifactly_publish_markdown",
       "artifactly_list_artifacts",
       "artifactly_get_artifact",
+      "artifactly_update_artifact",
+      "artifactly_delete_artifact",
+      "artifactly_publish_file",
     ]);
   });
 
@@ -44,6 +48,30 @@ describe("Artifactly MCP tools", () => {
     rmSync(dir, { recursive: true, force: true });
   });
 
+  it("logs out by clearing the shared credential store", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_logout", credentialPath }),
+    ).resolves.toEqual({ ok: true, authenticated: false });
+    expect(existsSync(credentialPath)).toBe(false);
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_auth_status", credentialPath }),
+    ).resolves.toEqual({ authenticated: false, apiBaseUrl: "https://artifactly.io" });
+
+    rmSync(dir, { recursive: true, force: true });
+  });
+
   it("publishes markdown through the Artifactly API without returning secrets", async () => {
     const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
     const credentialPath = join(dir, "credentials.json");
@@ -88,4 +116,140 @@ describe("Artifactly MCP tools", () => {
 
     rmSync(dir, { recursive: true, force: true });
   });
+
+  it("lists, gets, updates, and deletes artifacts through authenticated API requests", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    const requests: Array<{ method: string; path: string; body?: unknown; apiKey?: string }> = [];
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    const requestJson = async (method: string, path: string, body?: unknown, options?: { apiKey?: string }) => {
+      requests.push({ method, path, body, apiKey: options?.apiKey });
+      if (method === "GET" && path === "/api/artifacts") {
+        return { artifacts: [{ id: "artifact_1", title: "Hello" }] };
+      }
+      if (method === "GET" && path === "/api/artifacts/artifact_1") {
+        return { artifact: { id: "artifact_1", title: "Hello" } };
+      }
+      if (method === "PATCH" && path === "/api/artifacts/artifact_1") {
+        return { artifact: { id: "artifact_1", title: "Updated", visibility: "private" } };
+      }
+      return { ok: true, artifactId: "artifact_1" };
+    };
+
+    await expect(
+      callArtifactlyMcpTool({ name: "artifactly_list_artifacts", credentialPath, requestJson }),
+    ).resolves.toEqual({ artifacts: [{ id: "artifact_1", title: "Hello" }] });
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_get_artifact",
+        credentialPath,
+        arguments: { artifactId: "artifact_1" },
+        requestJson,
+      }),
+    ).resolves.toEqual({ artifact: { id: "artifact_1", title: "Hello" } });
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_update_artifact",
+        credentialPath,
+        arguments: {
+          artifactId: "artifact_1",
+          title: "Updated",
+          visibility: "private",
+          accessList: ["agent@example.com"],
+        },
+        requestJson,
+      }),
+    ).resolves.toEqual({ artifact: { id: "artifact_1", title: "Updated", visibility: "private" } });
+    await expect(
+      callArtifactlyMcpTool({
+        name: "artifactly_delete_artifact",
+        credentialPath,
+        arguments: { artifactId: "artifact_1" },
+        requestJson,
+      }),
+    ).resolves.toEqual({ ok: true, artifactId: "artifact_1" });
+
+    expect(requests).toEqual([
+      { method: "GET", path: "/api/artifacts", apiKey: "art_t...et", body: undefined },
+      { method: "GET", path: "/api/artifacts/artifact_1", apiKey: "art_t...et", body: undefined },
+      {
+        method: "PATCH",
+        path: "/api/artifacts/artifact_1",
+        apiKey: "art_t...et",
+        body: { title: "Updated", visibility: "private", accessList: ["agent@example.com"] },
+      },
+      { method: "DELETE", path: "/api/artifacts/artifact_1", apiKey: "art_t...et", body: undefined },
+    ]);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  it("publishes local HTML and PDF files through the artifact API", async () => {
+    const dir = mkdtempSync(join(tmpdir(), "artifactly-mcp-"));
+    const credentialPath = join(dir, "credentials.json");
+    const htmlPath = join(dir, "hello.html");
+    const pdfPath = join(dir, "hello.pdf");
+    const requests: Array<{ path: string; body: unknown; apiKey?: string }> = [];
+    writeFileSync(htmlPath, "<h1>Hello</h1>");
+    writeFileSync(pdfPath, Buffer.from("%PDF-1.4\nhello"));
+    writeCredentials(
+      {
+        apiBaseUrl: "https://artifactly.example",
+        apiKey: "art_t...et",
+        email: "agent@example.com",
+        workspace: "agent",
+      },
+      credentialPath,
+    );
+
+    const postJson = async (path: string, body: unknown, options?: { apiKey?: string }) => {
+      requests.push({ path, body, apiKey: options?.apiKey });
+      return { id: "artifact_1", url: "https://artifactly.example/share/agent/hello" };
+    };
+
+    await callArtifactlyMcpTool({
+      name: "artifactly_publish_file",
+      credentialPath,
+      arguments: { path: htmlPath, visibility: "public" },
+      postJson,
+    });
+    await callArtifactlyMcpTool({
+      name: "artifactly_publish_file",
+      credentialPath,
+      arguments: { path: pdfPath, title: "PDF Hello", mimeType: "application/pdf" },
+      postJson,
+    });
+
+    expect(requests).toEqual([
+      {
+        path: "/api/artifacts",
+        apiKey: "art_t...et",
+        body: {
+          title: "hello",
+          kind: "html",
+          content: "<h1>Hello</h1>",
+          visibility: "public",
+        },
+      },
+      {
+        path: "/api/artifacts",
+        apiKey: "art_t...et",
+        body: {
+          title: "PDF Hello",
+          kind: "file",
+          storageUrl: "data:application/pdf;base64,JVBERi0xLjQKaGVsbG8=",
+          visibility: "unlisted",
+        },
+      },
+    ]);
+    rmSync(dir, { recursive: true, force: true });
+  });
 });

package/src/mcp/artifactly-mcp.ts

@@ -1,4 +1,8 @@
+import { readFileSync } from "node:fs";
+import { basename, extname } from "node:path";
+
 import {
+  clearCredentials,
   createDefaultPostJson,
   getDefaultCredentialPath,
   readCredentials,
@@ -18,8 +22,41 @@ type CallToolInput = {
   credentialPath?: string;
   apiBaseUrl?: string;
   postJson?: PostJson;
+  requestJson?: RequestJson;
 };
 
+type RequestJson = (
+  method: string,
+  path: string,
+  body?: unknown,
+  options?: { apiKey?: string },
+) => Promise<unknown>;
+
+function createDefaultRequestJson(apiBaseUrl: string): RequestJson {
+  return async (method, path, body, options) => {
+    const response = await fetch(`${apiBaseUrl}${path}`, {
+      method,
+      headers: {
+        ...(body === undefined ? {} : { "content-type": "application/json" }),
+        ...(options?.apiKey ? { authorization: `Bearer ${options.apiKey}` } : {}),
+      },
+      ...(body === undefined ? {} : { body: JSON.stringify(body) }),
+    });
+    const payload = (await response.json().catch(() => ({}))) as unknown;
+    if (!response.ok) {
+      const message =
+        typeof payload === "object" &&
+        payload !== null &&
+        "error" in payload &&
+        typeof payload.error === "string"
+          ? payload.error
+          : `Artifactly API request failed with ${response.status}`;
+      throw new Error(message);
+    }
+    return payload;
+  };
+}
+
 function stringArg(
   args: Record<string, unknown> | undefined,
   key: string,
@@ -39,6 +76,17 @@ function requireStringArg(
   return value;
 }
 
+function stringArrayArg(
+  args: Record<string, unknown> | undefined,
+  key: string,
+): string[] | undefined {
+  const value = args?.[key];
+  if (!Array.isArray(value)) {
+    return undefined;
+  }
+  return value.filter((item): item is string => typeof item === "string");
+}
+
 function objectResult(value: unknown): Record<string, unknown> {
   if (!value || typeof value !== "object" || Array.isArray(value)) {
     throw new Error("Artifactly API returned an unexpected response.");
@@ -46,6 +94,30 @@ function objectResult(value: unknown): Record<string, unknown> {
   return value as Record<string, unknown>;
 }
 
+function titleFromPath(path: string): string {
+  const name = basename(path, extname(path));
+  return name || "artifact";
+}
+
+function inferMimeType(path: string): string {
+  const extension = extname(path).toLowerCase();
+  if (extension === ".pdf") return "application/pdf";
+  if (extension === ".html" || extension === ".htm") return "text/html";
+  if (extension === ".json") return "application/json";
+  if (extension === ".md" || extension === ".markdown") return "text/markdown";
+  if (extension === ".txt") return "text/plain";
+  return "application/octet-stream";
+}
+
+function kindForMime(path: string, mimeType: string) {
+  const extension = extname(path).toLowerCase();
+  const normalized = mimeType.toLowerCase();
+  if (normalized.includes("html") || extension === ".html" || extension === ".htm") return "html";
+  if (normalized.includes("json") || extension === ".json") return "json";
+  if (normalized.includes("markdown") || extension === ".md" || extension === ".markdown") return "markdown";
+  return "file";
+}
+
 export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
   return [
     {
@@ -72,6 +144,11 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
         required: ["email", "code"],
       },
     },
+    {
+      name: "artifactly_logout",
+      description: "Log out by clearing the local Artifactly credential store.",
+      inputSchema: { type: "object", properties: {} },
+    },
     {
       name: "artifactly_publish_markdown",
       description: "Publish markdown through the Artifactly API using stored credentials.",
@@ -99,6 +176,46 @@ export function listArtifactlyMcpTools(): ArtifactlyMcpTool[] {
         required: ["artifactId"],
       },
     },
+    {
+      name: "artifactly_update_artifact",
+      description: "Update an existing Artifactly artifact, including visibility and gated access emails.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          artifactId: { type: "string" },
+          title: { type: "string" },
+          markdown: { type: "string" },
+          content: { type: "string" },
+          description: { type: "string" },
+          visibility: { type: "string", enum: ["public", "unlisted", "private", "gated"] },
+          accessList: { type: "array", items: { type: "string" } },
+        },
+        required: ["artifactId"],
+      },
+    },
+    {
+      name: "artifactly_delete_artifact",
+      description: "Delete an existing Artifactly artifact owned by the authenticated account.",
+      inputSchema: {
+        type: "object",
+        properties: { artifactId: { type: "string" } },
+        required: ["artifactId"],
+      },
+    },
+    {
+      name: "artifactly_publish_file",
+      description: "Publish a local PDF, HTML, JSON, Markdown, or other file through the Artifactly API.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          title: { type: "string" },
+          mimeType: { type: "string" },
+          visibility: { type: "string", enum: ["public", "unlisted", "private", "gated"] },
+        },
+        required: ["path"],
+      },
+    },
   ];
 }
 
@@ -107,6 +224,7 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
   const credentials = readCredentials(credentialPath);
   const apiBaseUrl = input.apiBaseUrl ?? credentials?.apiBaseUrl ?? "https://artifactly.io";
   const postJson = input.postJson ?? createDefaultPostJson(apiBaseUrl);
+  const requestJson = input.requestJson ?? createDefaultRequestJson(apiBaseUrl);
 
   if (input.name === "artifactly_auth_status") {
     return credentials
@@ -155,6 +273,11 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
     };
   }
 
+  if (input.name === "artifactly_logout") {
+    clearCredentials(credentialPath);
+    return { ok: true, authenticated: false };
+  }
+
   if (input.name === "artifactly_publish_markdown") {
     if (!credentials) {
       throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
@@ -172,17 +295,83 @@ export async function callArtifactlyMcpTool(input: CallToolInput) {
   }
 
   if (input.name === "artifactly_list_artifacts") {
-    return {
-      error:
-        "Artifact list API is not available yet. This MCP tool is reserved for the next API expansion.",
-    };
+    if (!credentials) {
+      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+    }
+    return objectResult(await requestJson("GET", "/api/artifacts", undefined, { apiKey: credentials.apiKey }));
   }
 
   if (input.name === "artifactly_get_artifact") {
-    return {
-      error:
-        "Artifact lookup API is not available yet. This MCP tool is reserved for the next API expansion.",
-    };
+    if (!credentials) {
+      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+    }
+    const artifactId = requireStringArg(input.arguments, "artifactId");
+    return objectResult(await requestJson("GET", `/api/artifacts/${artifactId}`, undefined, { apiKey: credentials.apiKey }));
+  }
+
+  if (input.name === "artifactly_update_artifact") {
+    if (!credentials) {
+      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+    }
+    const artifactId = requireStringArg(input.arguments, "artifactId");
+    const title = stringArg(input.arguments, "title");
+    const markdown = stringArg(input.arguments, "markdown");
+    const content = stringArg(input.arguments, "content");
+    const description = stringArg(input.arguments, "description");
+    const visibility = stringArg(input.arguments, "visibility");
+    const accessList = stringArrayArg(input.arguments, "accessList");
+    return objectResult(
+      await requestJson(
+        "PATCH",
+        `/api/artifacts/${artifactId}`,
+        {
+          ...(title ? { title } : {}),
+          ...(markdown ? { markdown } : {}),
+          ...(content ? { content } : {}),
+          ...(description ? { description } : {}),
+          ...(visibility ? { visibility } : {}),
+          ...(accessList ? { accessList } : {}),
+        },
+        { apiKey: credentials.apiKey },
+      ),
+    );
+  }
+
+  if (input.name === "artifactly_delete_artifact") {
+    if (!credentials) {
+      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+    }
+    const artifactId = requireStringArg(input.arguments, "artifactId");
+    return objectResult(await requestJson("DELETE", `/api/artifacts/${artifactId}`, undefined, { apiKey: credentials.apiKey }));
+  }
+
+  if (input.name === "artifactly_publish_file") {
+    if (!credentials) {
+      throw new Error("Artifactly credentials are not configured. Run artifactly_request_login_code first.");
+    }
+    const path = requireStringArg(input.arguments, "path");
+    const title = stringArg(input.arguments, "title") ?? titleFromPath(path);
+    const mimeType = stringArg(input.arguments, "mimeType") ?? inferMimeType(path);
+    const visibility = stringArg(input.arguments, "visibility") ?? "unlisted";
+    const kind = kindForMime(path, mimeType);
+    const file = readFileSync(path);
+    const payload =
+      kind === "file"
+        ? {
+            title,
+            kind,
+            storageUrl: `data:${mimeType};base64,${file.toString("base64")}`,
+            visibility,
+          }
+        : {
+            title,
+            kind,
+            content: file.toString("utf8"),
+            visibility,
+          };
+    return objectResult(
+      await postJson("/api/artifacts", payload, { apiKey: credentials.apiKey }),
+    );
   }
 
   throw new Error(`Unknown Artifactly MCP tool: ${input.name}`);