patchcord 0.6.41 → 0.6.43

package/scripts/build-agent-plugin.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+/**
+ * Generate the Agent Plugins 1.0.0 distribution at ./agent-plugin/.
+ *
+ * PURELY ADDITIVE. This does not touch .claude-plugin/, skills/, hooks/,
+ * commands/, or anything the current installer writes. Every existing harness
+ * keeps working exactly as it does today; the generated directory is a second,
+ * parallel packaging of the same content for clients that load the open
+ * standard (Codex/ChatGPT, Cursor, GitHub Copilot, Kiro, VS Code).
+ *
+ * WHY GENERATED RATHER THAN HAND-WRITTEN
+ *
+ * The skills are the same skills. Copying them by hand would create two
+ * SKILL.md bodies that drift, and the drift would be silent — both files stay
+ * valid, they just stop agreeing. Deriving them means the source of truth
+ * remains ./skills/ and this script is the only thing that has to be re-run.
+ *
+ * THE ONE TRANSFORM APPLIED
+ *
+ * Our skills declare `name: patchcord:inbox`. The Agent Skills specification
+ * that Agent Plugins defers to requires the name to be lowercase alphanumeric
+ * plus hyphens ONLY (a colon is invalid) and to MATCH THE PARENT DIRECTORY.
+ * Every real Codex plugin on this machine follows that rule.
+ *
+ * So the generated copies get `name: <directory>`. The originals are left
+ * alone, because that string is what Claude Code surfaces as
+ * `/patchcord:inbox` and renaming it in place would change a user-facing
+ * command name to fix a spec violation nobody is currently enforcing. Two
+ * packagings, two conventions, one body.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, existsSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+const OUT = join(ROOT, "agent-plugin");
+const SKILLS_SRC = join(ROOT, "skills");
+
+const pkg = JSON.parse(readFileSync(join(ROOT, "package.json"), "utf-8"));
+const VERSION = pkg.version;
+const BASE_URL = "https://mcp.patchcord.dev";
+
+// Regenerate from scratch so a skill deleted upstream does not linger here.
+if (existsSync(OUT)) rmSync(OUT, { recursive: true });
+mkdirSync(join(OUT, ".codex-plugin"), { recursive: true });
+
+/* ---------- skills: copied, with `name` rewritten to the directory ---------- */
+
+const skillNames = readdirSync(SKILLS_SRC, { withFileTypes: true })
+  .filter((d) => d.isDirectory() && existsSync(join(SKILLS_SRC, d.name, "SKILL.md")))
+  .map((d) => d.name);
+
+if (skillNames.length === 0) {
+  console.error("build-agent-plugin: no skills found under ./skills — refusing to emit an empty plugin");
+  process.exit(1);
+}
+
+for (const name of skillNames) {
+  const body = readFileSync(join(SKILLS_SRC, name, "SKILL.md"), "utf-8");
+  // Replace only the `name:` line inside the leading frontmatter block. Anchored
+  // to the start of the file so a later `name:` in prose cannot be hit.
+  const fm = body.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fm) {
+    console.error(`build-agent-plugin: ${name}/SKILL.md has no frontmatter — refusing to guess`);
+    process.exit(1);
+  }
+  const rewritten = body.replace(/^(---\r?\n[\s\S]*?)^name:[ \t]*.*$/m, `$1name: ${name}`);
+  if (rewritten === body && !new RegExp(`^name:[ \\t]*${name}\\s*$`, "m").test(fm[1])) {
+    console.error(`build-agent-plugin: could not rewrite name: in ${name}/SKILL.md`);
+    process.exit(1);
+  }
+  mkdirSync(join(OUT, "skills", name), { recursive: true });
+  writeFileSync(join(OUT, "skills", name, "SKILL.md"), rewritten);
+}
+
+/* ---------- Agent Plugins 1.0.0 core: plugin.json + mcp.json ---------- */
+
+// The AP manifest schema is CLOSED (additionalProperties: false). Only the
+// fields it names may appear — notably there is no `skills` pointer, because
+// the spec fixes that location at ./skills/ rather than letting a manifest
+// redirect it.
+writeFileSync(join(OUT, "plugin.json"), JSON.stringify({
+  $schema: "https://agent-plugins.org/schemas/1.0.0/plugin.schema.json",
+  name: "patchcord",
+  version: VERSION,
+  description: pkg.description,
+  author: { name: "ppravdin", url: "https://patchcord.dev" },
+  homepage: "https://patchcord.dev",
+  repository: "https://github.com/ppravdin/patchcord",
+  license: pkg.license,
+  keywords: pkg.keywords,
+}, null, 2) + "\n");
+
+// NOTE THE MISSING CREDENTIAL, DELIBERATELY.
+//
+// Agent Plugins 1.0.0 defines placeholder expansion for ${PLUGIN_ROOT} and
+// ${PLUGIN_DATA} ONLY, and only in `args`, `env`, and `cwd`. `headers` is not
+// in that list, and the spec has no host-environment passthrough at all. So
+// there is no conformant way to say "put THIS user's bearer in the
+// Authorization header" in this file.
+//
+// Writing `"Authorization": "Bearer ${PATCHCORD_TOKEN}"` here would produce a
+// file that looks correct and sends the literal string `${PATCHCORD_TOKEN}` to
+// the server. That is worse than an obviously incomplete file, so this one is
+// obviously incomplete: it names the endpoint and the transport and stops.
+//
+// Clients supply the missing half through their own extensions — Codex via
+// `bearer_token_env_var` in .mcp.json (below), VS Code via `envFile`/`headers`.
+// See agent-plugin/README.md.
+writeFileSync(join(OUT, "mcp.json"), JSON.stringify({
+  $schema: "https://agent-plugins.org/schemas/1.0.0/mcp.schema.json",
+  mcpServers: {
+    patchcord: { type: "streamable-http", url: `${BASE_URL}/mcp` },
+  },
+}, null, 2) + "\n");
+
+/* ---------- Codex client files ---------- */
+
+// Codex reads .codex-plugin/plugin.json with POINTER fields (skills, mcpServers)
+// rather than the spec's fixed locations, so it needs its own manifest. Both
+// live in one directory without colliding: different filenames, different paths.
+writeFileSync(join(OUT, ".codex-plugin", "plugin.json"), JSON.stringify({
+  name: "patchcord",
+  version: VERSION,
+  description: pkg.description,
+  author: { name: "ppravdin", url: "https://patchcord.dev" },
+  homepage: "https://patchcord.dev",
+  repository: "https://github.com/ppravdin/patchcord",
+  license: pkg.license,
+  keywords: pkg.keywords,
+  skills: "./skills/",
+  mcpServers: "./.mcp.json",
+}, null, 2) + "\n");
+
+// `bearer_token_env_var` is Codex's own field — it names an environment
+// variable to read the token FROM, so the credential never enters this file.
+// That is what makes the plugin publishable: it carries no secret and is
+// identical for every user.
+writeFileSync(join(OUT, ".mcp.json"), JSON.stringify({
+  mcpServers: {
+    patchcord: {
+      type: "http",
+      url: `${BASE_URL}/mcp`,
+      bearer_token_env_var: "PATCHCORD_TOKEN",
+    },
+  },
+}, null, 2) + "\n");
+
+/* ---------- README (emitted, because this directory is wiped each build) ---------- */
+
+writeFileSync(join(OUT, "README.md"), `# patchcord — Agent Plugins 1.0.0 packaging
+
+**Generated. Do not edit by hand** — run \`node scripts/build-agent-plugin.mjs\`.
+This whole directory is deleted and rewritten on every build.
+
+This is an EXPERIMENTAL second packaging of the same skills and the same MCP
+server. It replaces nothing. \`npx patchcord\` and every per-harness config the
+installer writes are untouched and keep working exactly as before.
+
+## What is in here
+
+| File | Read by | Purpose |
+|---|---|---|
+| \`plugin.json\` | Agent Plugins clients | The open-standard manifest. Required: \`$schema\`, \`name\`. |
+| \`mcp.json\` | Agent Plugins clients | Standard MCP declaration. **Carries no credential — see below.** |
+| \`.codex-plugin/plugin.json\` | Codex | Codex uses pointer fields (\`skills\`, \`mcpServers\`) instead of the spec's fixed locations. |
+| \`.mcp.json\` | Codex | Codex MCP config, with the token read from an env var. |
+| \`skills/*/SKILL.md\` | both | Copied from \`../skills/\`, with \`name:\` rewritten to the directory name. |
+
+## The credential, and why \`mcp.json\` looks incomplete
+
+Agent Plugins 1.0.0 expands \`\${PLUGIN_ROOT}\` and \`\${PLUGIN_DATA}\` only, and
+only inside \`args\`, \`env\`, and \`cwd\`. \`headers\` is not in that list and there
+is no host-environment passthrough anywhere in the spec.
+
+So **the standard has no way to express "use this user's bearer token"**, and
+patchcord is nothing but a per-project bearer token. Writing
+\`"Authorization": "Bearer \${PATCHCORD_TOKEN}"\` into \`mcp.json\` would send that
+literal string to the server. The file therefore names the endpoint and the
+transport and stops, rather than looking complete and failing at runtime.
+
+Clients close the gap with their own extensions, which is where the token
+actually comes from:
+
+- **Codex** — \`bearer_token_env_var\` in \`.mcp.json\`, pointing at
+  \`$PATCHCORD_TOKEN\`.
+- **VS Code** — \`envFile\` / \`headers\`, neither of which is in the core schema.
+
+This is the one finding worth taking upstream: the portable core can carry the
+server's identity everywhere, but not its credential.
+
+## Trying it in Codex
+
+The marketplace is already registered, so:
+
+\`\`\`bash
+export PATCHCORD_TOKEN=<an agent bearer for the namespace you want>
+codex plugin add patchcord-ap@patchcord-marketplace
+\`\`\`
+
+Remove it with \`codex plugin remove patchcord-ap@patchcord-marketplace\`. The
+existing \`patchcord@patchcord-marketplace\` entry is unaffected either way.
+
+## Known limitation: one token per environment
+
+\`$PATCHCORD_TOKEN\` is a single value per shell, while patchcord's model is one
+namespace per project. A plugin installed this way is therefore **one identity
+per environment**, not one per project — the same constraint that already
+applies to Hermes, and the reason the current per-project installer writes
+per-directory config instead. Do not use this packaging for multi-seat work
+until the standard grows a per-project secret mechanism.
+`);
+
+console.log(`build-agent-plugin: wrote agent-plugin/ (v${VERSION}, skills: ${skillNames.join(", ")})`);

package/scripts/lib/resolve-project-bearer.mjs

@@ -126,6 +126,43 @@ const opencodeReader = (cwd) => readJsonAt(join(cwd, "opencode.json"), ["mcp", "
 const antigravityReader = (cwd) => readJsonAt(join(cwd, ".agents", "mcp_config.json"), ["mcpServers", "patchcord"], "antigravity");
 const grokReader = (cwd) => readGrokTomlShape(join(cwd, ".grok", "config.toml"));
 const codexReader = (cwd) => readCodexTomlShape(join(cwd, ".codex", "config.toml"));
+// jcode: STDIO entry, so the bearer is in `args`, not in `headers`. readJsonAt
+// cannot see it -- extractBearer requires headers.Authorization and a url, and
+// this entry has neither. jcode has no HTTP transport, so an entry shaped like
+// every other harness's would be dropped at load time, and a reader shaped like
+// every other harness's finds nothing.
+//
+// Keyed on `patchcord-jcode`, matching what the installer writes. The distinct
+// name exists so jcode's own merge (.jcode/mcp.json, then .mcp.json, then
+// .claude/mcp.json -- later overriding by NAME) can never make jcode adopt
+// claude_code's credential.
+function readJcodeStdioShape(path) {
+  if (!existsSync(path)) return null;
+  try {
+    const obj = parseJsonc(readFileSync(path, "utf-8"));
+    const entry = obj?.mcpServers?.["patchcord-jcode"];
+    const args = Array.isArray(entry?.args) ? entry.args : null;
+    if (!args) return null;
+    // `--header` `Authorization: Bearer <token>` as two adjacent argv items.
+    let token = null;
+    for (let i = 0; i < args.length; i++) {
+      const m = typeof args[i] === "string" && args[i].match(/^Authorization:\s*Bearer\s+(\S+)$/i);
+      if (m) { token = m[1]; break; }
+    }
+    const urlArg = args.find((a) => typeof a === "string" && /^https?:\/\//.test(a));
+    if (!token || !urlArg) return null;
+    return {
+      token,
+      baseUrl: urlArg.replace(/\/mcp(\/bearer)?$/, ""),
+      configFile: path,
+      tool: "jcode",
+    };
+  } catch {
+    return null;
+  }
+}
+
+const jcodeReader = (cwd) => readJcodeStdioShape(join(cwd, ".jcode", "mcp.json"));
 const kimiReader = (cwd) => readJsonAt(join(cwd, ".kimi", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
 const kimiCodeReader = (cwd) => readJsonAt(join(cwd, ".kimi-code", "mcp.json"), ["mcpServers", "patchcord"], "kimi");
 
@@ -163,6 +200,7 @@ export function projectReadersForContext(ctx) {
     grok: grokReader,
     codex: codexReader,
     kimi: kimiCodeReader,
+    jcode: jcodeReader,
   };
   const defaultReaders = [
     claudeReader,
@@ -172,6 +210,7 @@ export function projectReadersForContext(ctx) {
     antigravityReader,
     grokReader,
     codexReader,
+    jcodeReader,
   ];
   const kimiReaders = [kimiReader, kimiCodeReader];
 
@@ -199,6 +238,7 @@ export function projectReadersForContext(ctx) {
       antigravityReader,
       grokReader,
       codexReader,
+      jcodeReader,
       claudeReader,
       ...kimiReaders,
     ];

package/scripts/sync-plugin-version.mjs

@@ -10,15 +10,30 @@ import { readFileSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
 import { dirname, join } from "node:path";
 
+// EVERY manifest, not the one that existed when this was written. A second
+// packaged plugin (agent-plugin/) arrived later and this script did not know
+// about it, so a merge left it claiming 0.6.40 inside a 0.6.42 package — the
+// same drift the comment above describes, reappearing the moment a new manifest
+// was added. A list is what stops the next one being missed: add the path here
+// and the sync is automatic, rather than a step someone must remember.
 const root = join(dirname(fileURLToPath(import.meta.url)), "..");
 const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
-const manifestPath = join(root, ".claude-plugin", "plugin.json");
-const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+const MANIFESTS = [
+  join(root, ".claude-plugin", "plugin.json"),
+  join(root, "agent-plugin", "plugin.json"),
+];
 
-if (manifest.version === pkg.version) {
-  process.exit(0);
+for (const manifestPath of MANIFESTS) {
+  let manifest;
+  try {
+    manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+  } catch {
+    // A manifest that is not present is not an error — agent-plugin/ is built
+    // in some trees and not others. A manifest that is present and STALE is.
+    continue;
+  }
+  if (manifest.version === pkg.version) continue;
+  manifest.version = pkg.version;
+  writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+  process.stderr.write(`synced ${manifestPath} version -> ${pkg.version}\n`);
 }
-
-manifest.version = pkg.version;
-writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
-process.stderr.write(`synced plugin.json version -> ${pkg.version}\n`);

package/skills/inbox/SKILL.md

@@ -114,7 +114,7 @@ To message a user outside your namespace, use `@username` as the to_agent. Examp
 ```
 patchcord upload /path/to/report.md --mime text/markdown
 ```
-Prints the storage path. Pass that path to `send_message`. No curl, no base64 in chat, no presigned URLs. 25MB cap.
+Prints the storage path. Pass that path to `send_message`. No curl, no base64 in chat, no presigned URLs. The size limit is the server's, not a number to remember: it is 10 MiB by default and a self-hosted server can raise it. If a file is too large the command prints the server's own limit.
 
 **Public URLs → `attachment(relay=true, ...)`:**
 ```