plm-upload-mcp 1.0.0

package/README.md

@@ -0,0 +1,72 @@
+# plm-upload-mcp
+
+An MCP server that bulk-uploads local files (SolidWorks STEP/PDF exports) into the
+**LionsBot PLM**, matched to a component by SKU. It runs on **your own machine**, so
+it reads your exported files straight off disk, and it signs in as **you** with your
+PLM/hub login — every uploaded file is tagged with who uploaded it.
+
+Pair it with your SolidWorks MCP: that MCP knows each part's SKU and exports the files;
+this MCP takes `{path, sku}` pairs and pushes them into the PLM.
+
+## Setup
+
+Add one entry to your Claude MCP config (Claude Desktop: `claude_desktop_config.json`;
+Claude Code: `.mcp.json` or `claude mcp add`). Use **your own** PLM email + password:
+
+```json
+{
+  "mcpServers": {
+    "plm-upload": {
+      "command": "npx",
+      "args": ["-y", "plm-upload-mcp"],
+      "env": {
+        "PLM_EMAIL": "you@lionsbot.com",
+        "PLM_PASSWORD": "your-plm-password"
+      }
+    }
+  }
+}
+```
+
+That's all. `npx -y` fetches and runs the latest version; no clone, no build.
+
+> Your login is the same one you use for the Hardware Tools hub / PLM. Uploads are
+> attributed to you and require a `@lionsbot.com` account.
+
+## Tools
+
+### `upload_files`
+Uploads one or more files, each paired with its target SKU.
+
+- `files`: array of `{ path, sku, skuName?, category? }`
+  - `path` — absolute local path to the file
+  - `sku` — component SKU, e.g. `MNT-1234-A0`
+  - `skuName` — optional; only used if the SKU's Drive folder has to be created
+  - `category` — optional PLM tag: `Default` | `Archive` | `Compliance` | `Ops`
+- `bucket`: `main` (default, confirmed components) or `staging` (unconfirmed)
+
+Each file lands in PLM storage and is mirrored into that SKU's Google Drive folder
+(created automatically if it doesn't exist). Re-uploading a file with the **same name
+replaces it in place** — no duplicate pile-up on re-runs.
+
+Example ask: *"Upload C:\exports\bracket.step to SKU MNT-1234-A0 and C:\exports\bracket.pdf to the same SKU."*
+
+### `list_component_files`
+Lists the files currently in a component's Drive folder.
+
+- `sku`: component SKU
+- `bucket`: `main` (default) or `staging`
+
+## Config overrides (rarely needed)
+
+Baked to production defaults; override via env only if the PLM backend moves:
+
+| env | default |
+|---|---|
+| `PLM_GATEWAY` | `https://gateway-production-c13d.up.railway.app` |
+| `PLM_ANON_KEY` | (prod anon key) |
+| `PLM_EDGE_URL` | `https://plm-edge-production.up.railway.app` |
+
+## Requirements
+
+Node.js 18+ (for built-in `fetch`).

package/index.mjs

@@ -0,0 +1,205 @@
+#!/usr/bin/env node
+/**
+ * plm-upload-mcp — bulk-upload local files (SolidWorks STEP/PDF exports) into
+ * the LionsBot PLM, matched to a component by SKU.
+ *
+ * Runs locally on each engineer's machine (stdio), so it reads their exported
+ * files straight off disk. It authenticates as the engineer with their own PLM
+ * login (GoTrue password grant) and every uploaded file is tagged with who
+ * uploaded it, server-side, by the plm-edge `upload` action.
+ *
+ * Config (env):
+ *   PLM_EMAIL, PLM_PASSWORD   — the engineer's PLM/hub login (required)
+ *   PLM_GATEWAY, PLM_ANON_KEY, PLM_EDGE_URL — override the baked prod defaults
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
+import { z } from 'zod'
+import { readFile } from 'node:fs/promises'
+import { basename, extname } from 'node:path'
+
+// Prod defaults — same values the PLM web app ships with. Overridable via env.
+const GATEWAY = process.env.PLM_GATEWAY || 'https://gateway-production-c13d.up.railway.app'
+const ANON_KEY =
+  process.env.PLM_ANON_KEY ||
+  'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJyb2xlIjoiYW5vbiIsImlzcyI6InN1cGFiYXNlIiwiaWF0IjoxNzg0NzE1NTExLCJleHAiOjIxMDAwNzU1MTF9.kqtdfumqx4EjRyJ15Ld0gSZBYdeE0VnpmlnJy68qQT0'
+const EDGE = process.env.PLM_EDGE_URL || 'https://plm-edge-production.up.railway.app'
+const EMAIL = process.env.PLM_EMAIL
+const PASSWORD = process.env.PLM_PASSWORD
+
+const MIME = {
+  '.step': 'application/step',
+  '.stp': 'application/step',
+  '.pdf': 'application/pdf',
+  '.sldprt': 'application/octet-stream',
+  '.sldasm': 'application/octet-stream',
+  '.dxf': 'application/dxf',
+  '.dwg': 'application/acad',
+  '.igs': 'model/iges',
+  '.iges': 'model/iges',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+}
+const mimeFor = (name) => MIME[extname(name).toLowerCase()] || 'application/octet-stream'
+
+// --- Auth: cache one access token, re-grant when it's near expiry. -----------
+let cached = { token: null, exp: 0 }
+async function getToken() {
+  if (cached.token && Date.now() < cached.exp - 60_000) return cached.token
+  if (!EMAIL || !PASSWORD) throw new Error('PLM_EMAIL and PLM_PASSWORD must be set in the MCP config env.')
+  const resp = await fetch(`${GATEWAY}/auth/v1/token?grant_type=password`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', apikey: ANON_KEY },
+    body: JSON.stringify({ email: EMAIL, password: PASSWORD }),
+  })
+  const data = await resp.json().catch(() => null)
+  if (!resp.ok || !data?.access_token) {
+    throw new Error(`PLM sign-in failed for ${EMAIL}: ${data?.error_description || data?.msg || resp.status}`)
+  }
+  cached = { token: data.access_token, exp: Date.now() + (data.expires_in ?? 3600) * 1000 }
+  return cached.token
+}
+
+async function edgeJson(body) {
+  const token = await getToken()
+  const resp = await fetch(`${EDGE}/drive-library`, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: `Bearer ${token}` },
+    body: JSON.stringify(body),
+  })
+  const data = await resp.json().catch(() => null)
+  if (!resp.ok) throw new Error(data?.error || `edge ${body.action} failed: http ${resp.status}`)
+  return data
+}
+
+/** store bytes → storagePath, then upload → mirror into the SKU's Drive folder. */
+async function uploadOne({ path, sku, skuName, category, bucket }) {
+  const bytes = await readFile(path) // throws ENOENT with the path — surfaced per-file below
+  const filename = basename(path)
+  const mimeType = mimeFor(filename)
+  const token = await getToken()
+
+  const params = new URLSearchParams({ action: 'store', sku, filename, mimeType })
+  const sResp = await fetch(`${EDGE}/drive-library?${params}`, {
+    method: 'POST',
+    headers: { 'content-type': mimeType, authorization: `Bearer ${token}` },
+    body: bytes,
+  })
+  const stored = await sResp.json().catch(() => null)
+  if (!sResp.ok || !stored?.storagePath) {
+    throw new Error(stored?.error || `store failed: http ${sResp.status}`)
+  }
+
+  const synced = await edgeJson({
+    action: 'upload',
+    sku,
+    skuName: skuName ?? '',
+    storagePath: stored.storagePath,
+    filename,
+    mimeType,
+    bucket,
+  })
+  if (synced?.error) throw new Error(synced.error)
+
+  if (category && category !== 'Default' && synced?.driveFileId) {
+    await edgeJson({ action: 'set-category', fileId: synced.driveFileId, category }).catch(() => {})
+  }
+
+  return {
+    file: filename,
+    sku,
+    driveFileId: synced.driveFileId,
+    driveWebViewLink: synced.driveWebViewLink,
+    replaced: !!synced.replaced,
+    category: category && category !== 'Default' ? category : undefined,
+  }
+}
+
+// --- Server ------------------------------------------------------------------
+const server = new McpServer({ name: 'plm-upload', version: '1.0.0' })
+
+server.registerTool(
+  'upload_files',
+  {
+    title: 'Upload files to PLM by SKU',
+    description:
+      "Bulk-upload local files (e.g. SolidWorks STEP/PDF exports) into the LionsBot PLM. " +
+      "Each file is attached to a component by its SKU: it lands in PLM storage and is mirrored " +
+      "into that SKU's Google Drive folder (folder auto-created if missing). Re-uploading a file " +
+      "with the same name replaces it in place rather than duplicating. You must supply the SKU " +
+      "for each file — the caller's own tooling (e.g. a SolidWorks MCP) already knows each part's SKU.",
+    inputSchema: {
+      files: z
+        .array(
+          z.object({
+            path: z.string().describe('Absolute local path to the file to upload.'),
+            sku: z.string().describe('Component SKU this file belongs to, e.g. MNT-1234-A0.'),
+            skuName: z
+              .string()
+              .optional()
+              .describe("Component display name — used only if the SKU's Drive folder must be created."),
+            category: z
+              .enum(['Default', 'Archive', 'Compliance', 'Ops'])
+              .optional()
+              .describe('PLM file category tag. Defaults to Default.'),
+          }),
+        )
+        .min(1)
+        .describe('The files to upload, each paired with its target SKU.'),
+      bucket: z
+        .enum(['main', 'staging'])
+        .optional()
+        .describe("Which shared drive: 'main' (confirmed components, default) or 'staging' (unconfirmed)."),
+    },
+    annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+  },
+  async ({ files, bucket = 'main' }) => {
+    const results = []
+    for (const f of files) {
+      try {
+        results.push({ ok: true, ...(await uploadOne({ ...f, bucket })) })
+      } catch (e) {
+        results.push({ ok: false, file: basename(f.path), sku: f.sku, error: e instanceof Error ? e.message : String(e) })
+      }
+    }
+    const ok = results.filter((r) => r.ok).length
+    const lines = results.map((r) =>
+      r.ok
+        ? `✓ ${r.file} → ${r.sku}${r.replaced ? ' (replaced)' : ''}${r.category ? ` [${r.category}]` : ''}`
+        : `✗ ${r.file} → ${r.sku}: ${r.error}`,
+    )
+    return {
+      content: [{ type: 'text', text: `Uploaded ${ok}/${results.length} to ${bucket}.\n${lines.join('\n')}` }],
+      structuredContent: { uploaded: ok, total: results.length, bucket, results },
+    }
+  },
+)
+
+server.registerTool(
+  'list_component_files',
+  {
+    title: 'List a component\'s PLM files',
+    description: "Lists the files currently in a component's Google Drive folder in the PLM, by SKU.",
+    inputSchema: {
+      sku: z.string().describe('Component SKU, e.g. MNT-1234-A0.'),
+      bucket: z.enum(['main', 'staging']).optional().describe("'main' (default) or 'staging'."),
+    },
+    annotations: { readOnlyHint: true, openWorldHint: true },
+  },
+  async ({ sku, bucket = 'main' }) => {
+    const data = await edgeJson({ action: 'list', sku, bucket })
+    const files = Array.isArray(data?.files) ? data.files : []
+    if (!data?.connected) {
+      return { content: [{ type: 'text', text: `Drive not connected or no folder for ${sku}.` }], structuredContent: { connected: false, files: [] } }
+    }
+    const lines = files.map((x) => `• ${x.name}${x.appProperties?.plmCategory ? ` [${x.appProperties.plmCategory}]` : ''}`)
+    return {
+      content: [{ type: 'text', text: files.length ? `${sku} — ${files.length} file(s):\n${lines.join('\n')}` : `${sku} — folder is empty.` }],
+      structuredContent: { connected: true, folder: data.folder ?? null, files },
+    }
+  },
+)
+
+const transport = new StdioServerTransport()
+await server.connect(transport)

package/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "plm-upload-mcp",
+  "version": "1.0.0",
+  "description": "MCP server to bulk-upload SolidWorks exports (STEP/PDF) into the LionsBot PLM by SKU.",
+  "license": "UNLICENSED",
+  "keywords": ["mcp", "modelcontextprotocol", "lionsbot", "plm", "solidworks"],
+  "type": "module",
+  "bin": {
+    "plm-upload-mcp": "index.mjs"
+  },
+  "files": [
+    "index.mjs",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.30.0",
+    "zod": "^3.23.8"
+  }
+}