@dshforge/agent-plugins 0.0.0-stage → 0.1.0

package/lib/rpc.js

@@ -0,0 +1,147 @@
+import { clientRequestSchema } from '@deepseek-ai/dsh-client-connection'
+import { readdir, stat } from 'node:fs/promises'
+import { join } from 'node:path'
+import { resolveExistingInside } from './paths.js'
+import { errorMessage } from './validation.js'
+
+/** Build the catalog-only Connection RPC handler without exposing config values. */
+export function createAgentPluginsRpcHandler(catalog, { install } = {}) {
+  const readCatalog = () => typeof catalog === 'function' ? catalog() : catalog
+  return async (endpoint, payload, signal, peer) => {
+    if (peer.principal.kind !== 'owner') {
+      return failure('agent-plugins/forbidden', 'Agent Plugins catalog is available to owner peers only')
+    }
+    if (signal.aborted) return failure('agent-plugins/cancelled', 'Agent Plugins catalog request was cancelled')
+    if (endpoint === 'catalog') return { ok: true, value: projectCatalog(readCatalog()) }
+    if (endpoint === 'files') return listPluginDirectory(readCatalog(), payload)
+    if (endpoint === 'install' && install !== undefined) {
+      if (typeof payload?.spec !== 'string') return failure('agent-plugins/invalid-request', 'install requires a Git spec')
+      try {
+        return { ok: true, value: await install(payload.spec, signal) }
+      } catch (error) {
+        return failure(typeof error?.code === 'string' && error.code.startsWith('agent-plugins/')
+          ? error.code
+          : 'agent-plugins/install-failed', errorMessage(error))
+      }
+    }
+    return failure('agent-plugins/not-found', `Unknown Agent Plugins endpoint ${JSON.stringify(endpoint)}`)
+  }
+}
+
+async function listPluginDirectory(catalog, payload) {
+  if (typeof payload?.root !== 'string' || typeof payload.path !== 'string') {
+    return failure('agent-plugins/invalid-request', 'files requires root and path')
+  }
+  const plugin = catalog.plugins.find(entry => entry.directoryName === payload.root)
+  if (!plugin || plugin.status !== 'ready') return failure('agent-plugins/not-found', 'Plugin directory was not found')
+  const relative = payload.path
+  if (relative.includes('\0') || relative.includes('\\') || relative.startsWith('/') || relative.split('/').includes('..')) {
+    return failure('agent-plugins/invalid-path', 'Directory path must stay within the plugin root')
+  }
+  const directory = join(plugin.root, relative)
+  let resolved
+  try {
+    resolved = await resolveExistingInside(plugin.root, directory)
+    if (!(await stat(resolved)).isDirectory()) {
+      return failure('agent-plugins/not-directory', 'Requested path is not a directory')
+    }
+  } catch (error) {
+    return failure('agent-plugins/invalid-path', errorMessage(error))
+  }
+  let entries
+  try {
+    entries = await readdir(resolved, { withFileTypes: true })
+  } catch (error) {
+    return failure('agent-plugins/unavailable', errorMessage(error))
+  }
+  const rows = entries
+    .filter(entry => !entry.isSymbolicLink() && (entry.isDirectory() || entry.isFile()))
+    .map(entry => ({
+      name: entry.name,
+      kind: entry.isDirectory() ? 'directory' : 'file',
+      path: relative ? `${relative}/${entry.name}` : entry.name,
+    }))
+    .sort((a, b) => a.kind === b.kind ? a.name.localeCompare(b.name) : a.kind === 'directory' ? -1 : 1)
+  return { ok: true, value: { path: relative, entries: rows.slice(0, 200), truncated: rows.length > 200 } }
+}
+
+/** Register the catalog over the existing authenticated Connection fetch bridge. */
+export function registerAgentPluginsRpc(ctx, catalog, options) {
+  const handler = createAgentPluginsRpcHandler(catalog, options)
+  return ctx.get('webServer').register({
+    kind: 'prefix',
+    path: '/agent-plugins',
+    handler: async (request, response) => {
+      const admission = ctx.connection.admit(request)
+      if ('rejection' in admission) {
+        response.writeHead(admission.rejection).end(admission.rejection === 401 ? 'unauthorized' : 'forbidden')
+        return
+      }
+      if (request.method !== 'POST') {
+        response.writeHead(404).end('not found')
+        return
+      }
+      const endpoint = new URL(request.url, 'http://localhost').pathname.slice('/agent-plugins/'.length)
+      if (!['catalog', 'files', 'install'].includes(endpoint)) {
+        response.writeHead(404).end('not found')
+        return
+      }
+      let message
+      try {
+        message = clientRequestSchema.parse(await readJson(request))
+      } catch {
+        response.writeHead(400).end('invalid client-request message')
+        return
+      }
+      if (message.method !== endpoint) {
+        response.writeHead(400).end('method does not match endpoint')
+        return
+      }
+      const controller = new AbortController()
+      response.on('close', () => controller.abort())
+      const result = await handler(endpoint, message.payload, controller.signal, admission.peer)
+      response.writeHead(200, { 'content-type': 'application/json' })
+      response.end(JSON.stringify({ type: 'server-response', rpcId: message.rpcId, result }))
+    },
+  })
+}
+
+async function readJson(request) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of request) {
+    size += chunk.byteLength
+    if (size > 1024 * 1024) {
+      request.destroy()
+      throw new Error('request body exceeds 1 MiB')
+    }
+    chunks.push(chunk)
+  }
+  return JSON.parse(Buffer.concat(chunks).toString('utf8'))
+}
+
+function failure(code, message) {
+  return { ok: false, error: { code, message, details: {} } }
+}
+
+/** Keep transport config useful to the UI without exposing env or header values. */
+function projectCatalog(catalog) {
+  return {
+    ...catalog,
+    plugins: catalog.plugins.map(plugin => ({
+      ...plugin,
+      mcpServers: plugin.mcpServers.map(server => ({
+        name: server.name,
+        type: server.type,
+        ...server.type === 'stdio' ? {
+          command: server.command,
+          args: server.args ?? [],
+          ...server.cwd === undefined ? {} : { cwd: server.cwd },
+        } : {
+          url: server.url,
+          headerNames: Object.keys(server.headers ?? {}),
+        },
+      })),
+    })),
+  }
+}

package/lib/skills.js

@@ -0,0 +1,54 @@
+import { BUNDLED_SKILL_RANK } from '@deepseek-ai/dsh-skill'
+import { discoverAgentPlugins, loadAgentSkill } from './discovery.js'
+import { INVALID_AGENT_PLUGIN, isMissingPath } from './validation.js'
+
+const PROVIDER = 'agent-plugins'
+const INVOCATION = { modelInvocable: true, userInvocable: true }
+
+/** Create a strict Agent Plugins v1 skill provider with on-demand body loading. */
+export function createAgentSkillProvider({ pluginsDirectory }) {
+  return {
+    name: PROVIDER,
+    async list(options = {}) {
+      options.signal?.throwIfAborted()
+      const catalog = await discoverAgentPlugins({ pluginsDirectory })
+      options.signal?.throwIfAborted()
+      return catalog.plugins.flatMap(plugin => plugin.skills.map(skill => ({
+        name: skill.name,
+        description: skill.description,
+        path: skill.path,
+        provider: PROVIDER,
+        source: PROVIDER,
+        rank: BUNDLED_SKILL_RANK,
+        invocation: INVOCATION,
+        resourceBase: { kind: 'directory', path: skill.directory },
+        locator: {
+          pluginRoot: plugin.root,
+          skillDirectory: skill.directory,
+          packageDirectory: skill.packageDirectory,
+        },
+        ...skill.metadata === undefined ? {} : { metadata: skill.metadata },
+      })))
+    },
+    async get(candidate, options = {}) {
+      try {
+        const document = await loadAgentSkill({ ...candidate.locator, signal: options.signal })
+        if (document === undefined) return undefined
+        return {
+          name: document.name,
+          description: document.description,
+          path: candidate.path,
+          provider: PROVIDER,
+          source: PROVIDER,
+          invocation: INVOCATION,
+          resourceBase: candidate.resourceBase,
+          content: document.content,
+          ...document.metadata === undefined ? {} : { metadata: document.metadata },
+        }
+      } catch (error) {
+        if (isMissingPath(error) || error.code === INVALID_AGENT_PLUGIN) return undefined
+        throw error
+      }
+    },
+  }
+}

package/lib/validation.js

@@ -0,0 +1,218 @@
+import Ajv2020 from 'ajv/dist/2020.js'
+import { validateHeaderName, validateHeaderValue } from 'node:http'
+import { isIP } from 'node:net'
+import { createRequire } from 'node:module'
+
+const require = createRequire(import.meta.url)
+const pluginSchema = require('../schemas/1.0.0/plugin.schema.json')
+const mcpSchema = require('../schemas/1.0.0/mcp.schema.json')
+
+export const PLUGIN_SCHEMA = 'https://agent-plugins.org/schemas/1.0.0/plugin.schema.json'
+export const MCP_SCHEMA = 'https://agent-plugins.org/schemas/1.0.0/mcp.schema.json'
+export const INVALID_AGENT_PLUGIN = 'AGENT_PLUGIN_INVALID'
+
+const MANIFEST_FIELDS = new Set([
+  '$schema', 'name', 'version', 'description', 'author', 'homepage', 'repository',
+  'license', 'keywords', 'extensions',
+])
+const SKILL_NAME = /^[a-z0-9]+(?:-[a-z0-9]+)*$/
+const ajv = new Ajv2020({ strict: false, allErrors: true })
+const validateManifestSchema = ajv.compile(pluginSchema)
+ajv.addSchema(mcpSchema)
+const validateMcpRootSchema = ajv.compile({
+  $schema: 'https://json-schema.org/draft/2020-12/schema',
+  type: 'object',
+  properties: {
+    $schema: { const: MCP_SCHEMA },
+    mcpServers: { type: 'object' },
+  },
+  required: ['$schema', 'mcpServers'],
+  additionalProperties: false,
+})
+const validateMcpServerSchema = ajv.getSchema(`${MCP_SCHEMA}#/$defs/server`)
+
+/** Create one validation failure suitable for isolated component reporting. */
+export function invalidAgentPlugin(message, path) {
+  const error = new Error(path ? `${path}: ${message}` : message)
+  error.code = INVALID_AGENT_PLUGIN
+  error.path = path
+  return error
+}
+
+export function isPlainObject(value) {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function isMissingPath(error) {
+  return error?.code === 'ENOENT' || error?.code === 'ENOTDIR'
+}
+
+export function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error)
+}
+
+function schemaMessage(validate) {
+  return ajv.errorsText(validate.errors, { separator: '; ', maxErrors: 3 })
+}
+
+/** Validate and sanitize plugin.json, including the two non-fatal exceptions. */
+export function validateManifest(value, path) {
+  if (!isPlainObject(value)) throw invalidAgentPlugin('plugin.json must contain an object', path)
+  const manifest = { ...value }
+  const diagnostics = []
+  for (const key of Object.keys(manifest)) {
+    if (MANIFEST_FIELDS.has(key)) continue
+    diagnostics.push({ component: 'manifest', path, message: `ignored unknown manifest field ${JSON.stringify(key)}` })
+    delete manifest[key]
+  }
+  if (Object.hasOwn(manifest, 'extensions') && !isPlainObject(manifest.extensions)) {
+    diagnostics.push({ component: 'manifest', path, message: 'ignored non-object extensions field' })
+    delete manifest.extensions
+  }
+  const extensions = manifest.extensions
+  if (extensions !== undefined) delete manifest.extensions
+  if (!validateManifestSchema(manifest)) {
+    throw invalidAgentPlugin(`invalid plugin.json: ${schemaMessage(validateManifestSchema)}`, path)
+  }
+  if (extensions !== undefined) manifest.extensions = extensions
+  return { manifest, diagnostics }
+}
+
+/** Validate the MCP document envelope without rejecting independent server entries. */
+export function validateMcpDocument(value, manifestSchema, path) {
+  if (!validateMcpRootSchema(value)) {
+    throw invalidAgentPlugin(`invalid mcp.json: ${schemaMessage(validateMcpRootSchema)}`, path)
+  }
+  if (schemaVersion(value.$schema) !== schemaVersion(manifestSchema)) {
+    throw invalidAgentPlugin('plugin.json and mcp.json target different Agent Plugins versions', path)
+  }
+  if (!isPlainObject(value.mcpServers)) throw invalidAgentPlugin('mcpServers must be an object', path)
+}
+
+function schemaVersion(value) {
+  return /^https:\/\/agent-plugins\.org\/schemas\/([^/]+)\//.exec(value)?.[1]
+}
+
+/** Validate one MCP server entry and its transport-level URL/header semantics. */
+export function validateMcpServer(name, value, path) {
+  if (!validateMcpServerSchema(value)) {
+    throw invalidAgentPlugin(`invalid MCP server ${JSON.stringify(name)}: ${schemaMessage(validateMcpServerSchema)}`, path)
+  }
+  if (value.type === 'stdio') {
+    if (!value.command.startsWith('./') && /[\\/]/.test(value.command)) {
+      throw invalidAgentPlugin(`MCP server ${JSON.stringify(name)} command must be a bare executable or ./ plugin-relative path`, path)
+    }
+    return
+  }
+  validateRemoteUrl(value.url, path)
+  validateHeaders(value.headers, path)
+}
+
+function validateRemoteUrl(value, path) {
+  let url
+  try {
+    url = new URL(value)
+  } catch {
+    throw invalidAgentPlugin('MCP endpoint must be an absolute HTTP(S) URL', path)
+  }
+  if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash) {
+    throw invalidAgentPlugin('MCP endpoint must be HTTP(S), without user information or a fragment', path)
+  }
+  if (url.protocol === 'http:' && !isLoopbackHostname(url.hostname)) {
+    throw invalidAgentPlugin('non-loopback MCP endpoints must use HTTPS', path)
+  }
+}
+
+function isLoopbackHostname(hostname) {
+  if (hostname === 'localhost') return true
+  const normalized = hostname.startsWith('[') && hostname.endsWith(']') ? hostname.slice(1, -1) : hostname
+  const family = isIP(normalized)
+  return (family === 4 && normalized.startsWith('127.')) || (family === 6 && normalized === '::1')
+}
+
+function validateHeaders(headers = {}, path) {
+  if (!isPlainObject(headers)) throw invalidAgentPlugin('MCP headers must be an object', path)
+  const names = new Set()
+  for (const [name, value] of Object.entries(headers)) {
+    try {
+      validateHeaderName(name)
+      validateHeaderValue(name, value)
+    } catch (error) {
+      throw invalidAgentPlugin(`invalid MCP header: ${errorMessage(error)}`, path)
+    }
+    const normalized = name.toLowerCase()
+    if (names.has(normalized)) throw invalidAgentPlugin(`duplicate MCP header ${JSON.stringify(name)}`, path)
+    names.add(normalized)
+  }
+}
+
+/** Parse and validate one SKILL.md document against the Agent Skills contract. */
+export function parseSkillDocument(raw, expectedName, path) {
+  const { data, body } = parseFrontmatter(raw, path)
+  const name = requiredString(data, 'name', 64, path)
+  if (!SKILL_NAME.test(name) || name !== expectedName) {
+    throw invalidAgentPlugin(`skill name ${JSON.stringify(name)} must be kebab-case and match parent directory ${JSON.stringify(expectedName)}`, path)
+  }
+  const description = requiredString(data, 'description', 1024, path)
+  const result = {
+    name,
+    description,
+    content: body.trim(),
+  }
+  if (Object.hasOwn(data, 'license')) result.license = optionalString(data, 'license', undefined, path)
+  if (Object.hasOwn(data, 'compatibility')) result.compatibility = optionalString(data, 'compatibility', 500, path)
+  if (Object.hasOwn(data, 'allowed-tools')) result.allowedTools = optionalString(data, 'allowed-tools', undefined, path)
+  if (Object.hasOwn(data, 'metadata')) {
+    if (!isPlainObject(data.metadata) || Object.values(data.metadata).some(value => typeof value !== 'string')) {
+      throw invalidAgentPlugin('skill metadata must map strings to strings', path)
+    }
+    result.metadata = { ...data.metadata }
+  }
+  return result
+}
+
+function requiredString(data, key, maximum, path) {
+  const value = data[key]
+  if (typeof value !== 'string' || value.length < 1 || value.length > maximum) {
+    throw invalidAgentPlugin(`skill ${key} must be a string of 1-${maximum} characters`, path)
+  }
+  return value
+}
+
+function optionalString(data, key, maximum, path) {
+  const value = data[key]
+  if (typeof value !== 'string' || value.length < 1 || (maximum !== undefined && value.length > maximum)) {
+    throw invalidAgentPlugin(`skill ${key} has an invalid string value`, path)
+  }
+  return value
+}
+
+function parseFrontmatter(raw, path) {
+  const firstLineEnd = raw.indexOf('\n')
+  if (firstLineEnd < 0 || raw.slice(0, firstLineEnd).replace(/\r$/, '') !== '---') {
+    throw invalidAgentPlugin('SKILL.md requires YAML frontmatter', path)
+  }
+  const start = firstLineEnd + 1
+  let lineStart = start
+  while (lineStart <= raw.length) {
+    const nextNewline = raw.indexOf('\n', lineStart)
+    const lineEnd = nextNewline < 0 ? raw.length : nextNewline
+    const line = raw.slice(lineStart, lineEnd).replace(/\r$/, '')
+    if (line === '---') {
+      const yamlText = raw.slice(start, lineStart)
+      let data
+      try {
+        data = parseYaml(yamlText)
+      } catch (error) {
+        throw invalidAgentPlugin(`invalid YAML frontmatter: ${errorMessage(error)}`, path)
+      }
+      if (!isPlainObject(data)) throw invalidAgentPlugin('skill frontmatter must be an object', path)
+      return { data, body: raw.slice(nextNewline < 0 ? raw.length : nextNewline + 1) }
+    }
+    if (nextNewline < 0) break
+    lineStart = nextNewline + 1
+  }
+  throw invalidAgentPlugin('SKILL.md frontmatter has no closing delimiter', path)
+}
+
+import { parse as parseYaml } from 'yaml'

package/package.json

@@ -1,6 +1,67 @@
 {
   "name": "@dshforge/agent-plugins",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "type": "module",
+  "description": "Agent Plugins v1 Skills and MCP support for DeepSeek Harness Web.",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "lib/",
+    "schemas/",
+    "cordis.patch.yml",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "test": "node --test tests/*.test.js"
+  },
+  "engines": {
+    "dsh": ">=0.2.1-rc.3 <0.3.0",
+    "node": ">=24.9.0"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-ui-layout",
+        "@deepseek-ai/dsh-client-ui-renderer",
+        "@deepseek-ai/dsh-client-ui-settings-general",
+        "@deepseek-ai/dsh-client-ui-sidebar-right",
+        "@deepseek-ai/dsh-client-connection",
+        "@deepseek-ai/dsh-client-locale"
+      ]
+    }
+  },
+  "dependencies": {
+    "@deepseek-ai/dsh-util-workspace-path": ">=0.2.1-rc.3 <0.3.0",
+    "ajv": "^8.17.1",
+    "execa": "^9.6.0",
+    "yaml": "^2.4.2"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/dsh-client-connection": ">=0.2.1-rc.3 <0.3.0",
+    "@deepseek-ai/dsh-mcp-client": ">=0.2.1-rc.3 <0.3.0",
+    "@deepseek-ai/dsh-skill": ">=0.2.1-rc.3 <0.3.0"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.5",
+    "@deepseek-ai/dsh-client-connection": ">=0.2.1-rc.3 <0.3.0",
+    "@deepseek-ai/dsh-mcp-client": ">=0.2.1-rc.3 <0.3.0",
+    "@deepseek-ai/dsh-skill": ">=0.2.1-rc.3 <0.3.0",
+    "@deepseek-ai/dsh-system-prompt": ">=0.2.1-rc.3 <0.3.0",
+    "@deepseek-ai/dsh-tools": ">=0.2.1-rc.3 <0.3.0",
+    "@modelcontextprotocol/client": "2.2.0",
+    "@modelcontextprotocol/node": "2.0.0",
+    "@modelcontextprotocol/server": "2.2.0",
+    "esbuild": "^0.25.0",
+    "zod": "4.4.3"
+  }
+}

package/schemas/1.0.0/mcp.schema.json

@@ -0,0 +1,120 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  "title": "Agent Plugins MCP Configuration",
+  "description": "Machine-readable schema for mcp.json in Agent Plugins 1.0.0. The Agent Plugins specification defines additional semantic and operational requirements.",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "const": "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+      "description": "Canonical identifier of the MCP configuration schema for the Agent Plugins version targeted by this document."
+    },
+    "mcpServers": {
+      "type": "object",
+      "additionalProperties": {
+        "$ref": "#/$defs/server"
+      }
+    }
+  },
+  "required": ["$schema", "mcpServers"],
+  "additionalProperties": false,
+  "$defs": {
+    "server": {
+      "title": "MCP server",
+      "oneOf": [
+        {
+          "$ref": "#/$defs/stdioServer"
+        },
+        {
+          "$ref": "#/$defs/streamableHttpServer"
+        },
+        {
+          "$ref": "#/$defs/sseServer"
+        }
+      ]
+    },
+    "stdioServer": {
+      "title": "stdio MCP server",
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "stdio"
+        },
+        "command": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Executable token. Resolution rules are defined by the Agent Plugins specification."
+        },
+        "args": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          }
+        },
+        "env": {
+          "type": "object",
+          "propertyNames": {
+            "not": {
+              "enum": ["PLUGIN_ROOT", "PLUGIN_DATA"]
+            }
+          },
+          "additionalProperties": {
+            "type": "string"
+          }
+        },
+        "cwd": {
+          "type": "string",
+          "pattern": "^(?:\\./|\\$\\{PLUGIN_ROOT\\}(?:/|$)|\\$\\{PLUGIN_DATA\\}(?:/|$))",
+          "description": "Plugin-relative, PLUGIN_ROOT-rooted, or PLUGIN_DATA-rooted working directory. Filesystem containment is validated separately."
+        }
+      },
+      "required": ["type", "command"],
+      "additionalProperties": false
+    },
+    "streamableHttpServer": {
+      "title": "Streamable HTTP MCP server",
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "streamable-http"
+        },
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "description": "MCP endpoint URL. URL semantics are defined by the Agent Plugins specification."
+        },
+        "headers": {
+          "$ref": "#/$defs/headers"
+        }
+      },
+      "required": ["type", "url"],
+      "additionalProperties": false
+    },
+    "sseServer": {
+      "title": "Legacy HTTP+SSE MCP server",
+      "type": "object",
+      "properties": {
+        "type": {
+          "const": "sse"
+        },
+        "url": {
+          "type": "string",
+          "minLength": 1,
+          "description": "MCP endpoint URL. URL semantics are defined by the Agent Plugins specification."
+        },
+        "headers": {
+          "$ref": "#/$defs/headers"
+        }
+      },
+      "required": ["type", "url"],
+      "additionalProperties": false
+    },
+    "headers": {
+      "title": "HTTP headers",
+      "type": "object",
+      "additionalProperties": {
+        "type": "string"
+      }
+    }
+  }
+}

package/schemas/1.0.0/plugin.schema.json

@@ -0,0 +1,65 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  "title": "Agent Plugins Manifest",
+  "description": "Machine-readable schema for plugin.json in Agent Plugins 1.0.0. The Agent Plugins specification defines additional semantic and operational requirements.",
+  "type": "object",
+  "properties": {
+    "$schema": {
+      "const": "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+      "description": "Canonical identifier of the plugin manifest schema for the Agent Plugins version targeted by this document."
+    },
+    "name": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 64,
+      "pattern": "^(?!.*(?:--|\\.\\.))[a-z0-9](?:[a-z0-9.-]*[a-z0-9])?$",
+      "description": "Human-readable plugin name."
+    },
+    "version": {
+      "type": "string"
+    },
+    "description": {
+      "type": "string"
+    },
+    "author": {
+      "type": "object",
+      "properties": {
+        "name": {
+          "type": "string"
+        },
+        "email": {
+          "type": "string"
+        },
+        "url": {
+          "type": "string"
+        }
+      },
+      "additionalProperties": false
+    },
+    "homepage": {
+      "type": "string"
+    },
+    "repository": {
+      "type": "string"
+    },
+    "license": {
+      "type": "string"
+    },
+    "keywords": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      }
+    },
+    "extensions": {
+      "type": "object",
+      "description": "Client-specific manifest data keyed by reverse-domain extension namespace. Agent Plugins assigns no semantics to namespace object contents.",
+      "additionalProperties": {
+        "type": "object"
+      }
+    }
+  },
+  "required": ["$schema", "name"],
+  "additionalProperties": false
+}