code-workspace-zhuiyi 0.1.0-beta.1

package/extensions/openspec-workspace/1.0.0/manifest.json

@@ -0,0 +1,27 @@
+{
+  "schemaVersion": 3,
+  "extensionSpecVersion": 1,
+  "experimental": true,
+  "id": "openspec-workspace",
+  "name": "OpenSpec Workspace",
+  "version": "1.0.0",
+  "entry": "init.js",
+  "entrySha256": "5d95dc6261ef686f81a61cc09f0cf1d87bbb5014512be8665df2cc9f9b9dae24",
+  "timeoutMs": 60000,
+  "outputs": [
+    {
+      "id": "codex-propose-skill",
+      "kind": "file",
+      "ownership": "exclusive",
+      "target": ".codex/skills/code-workspace-openspec-propose/SKILL.md",
+      "tools": ["codex"]
+    },
+    {
+      "id": "claude-propose-skill",
+      "kind": "file",
+      "ownership": "exclusive",
+      "target": ".claude/skills/code-workspace-openspec-propose/SKILL.md",
+      "tools": ["claude"]
+    }
+  ]
+}

package/extensions/zhuiyi-jira-mcp/0.1.0/artifacts/claude/server.json

@@ -0,0 +1,14 @@
+{
+  "command": "node",
+  "args": [
+    ".code-workspace/extensions/zhuiyi-jira-mcp/0.1.0/dist/index.js"
+  ],
+  "env": {
+    "JIRA_AUTH_TYPE": "cookie",
+    "JIRA_API_VERSION": "latest",
+    "JIRA_ALLOWED_HOSTS": "jira.in.wezhuiyi.com",
+    "JIRA_REQUIREMENT_FIELDS": "{\"acceptanceCriteria\":\"customfield_10042\",\"storyPoints\":\"customfield_10016\"}",
+    "JIRA_ATTACHMENT_DIR": ".jira-attachments",
+    "JIRA_ATTACHMENT_MAX_SIZE": "20MB"
+  }
+}

package/extensions/zhuiyi-jira-mcp/0.1.0/artifacts/codex/config.toml

@@ -0,0 +1,11 @@
+[mcp_servers.zhuiyi-jira]
+command = "node"
+args = [".code-workspace/extensions/zhuiyi-jira-mcp/0.1.0/dist/index.js"]
+
+[mcp_servers.zhuiyi-jira.env]
+JIRA_AUTH_TYPE = "cookie"
+JIRA_API_VERSION = "latest"
+JIRA_ALLOWED_HOSTS = "jira.in.wezhuiyi.com"
+JIRA_REQUIREMENT_FIELDS = '{"acceptanceCriteria":"customfield_10042","storyPoints":"customfield_10016"}'
+JIRA_ATTACHMENT_DIR = ".jira-attachments"
+JIRA_ATTACHMENT_MAX_SIZE = "20MB"

package/extensions/zhuiyi-jira-mcp/0.1.0/init.js

@@ -0,0 +1,53 @@
+#!/usr/bin/env node
+
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { prepareRelease } = require("./lib/archive");
+const release = require("./release.json");
+
+function option(name) {
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : null;
+}
+
+function copyOutput(outputRoot, source, target) {
+  const destination = path.join(outputRoot, ...target.split("/"));
+  fs.mkdirSync(path.dirname(destination), { recursive: true });
+  fs.copyFileSync(path.join(__dirname, ...source.split("/")), destination);
+}
+
+async function main() {
+  const contextFile = option("--context");
+  const outputRoot = option("--output");
+  const resultFile = option("--result");
+  if (!contextFile || !outputRoot || !resultFile) throw new Error("Usage: init.js --context <file> --output <directory> --result <file>");
+  const context = JSON.parse(fs.readFileSync(contextFile, "utf8"));
+  if (context.schemaVersion !== 1 || context.extensionSpecVersion !== 1 || context.extension?.id !== "zhuiyi-jira-mcp" || context.extension.version !== "0.1.0" || !Array.isArray(context.tools)) throw new Error("Invalid extension context");
+
+  const outputs = [];
+  const runtime = path.join(outputRoot, "runtime");
+  await prepareRelease(release, runtime);
+  outputs.push({ id: "runtime", source: "runtime" });
+
+  if (context.tools.includes("codex")) {
+    copyOutput(outputRoot, "artifacts/codex/config.toml", "codex-config.toml");
+    outputs.push({ id: "codex-config", source: "codex-config.toml" });
+  }
+  if (context.tools.includes("claude")) {
+    copyOutput(outputRoot, "artifacts/claude/server.json", "claude-server.json");
+    outputs.push({ id: "claude-config", source: "claude-server.json" });
+  }
+
+  fs.writeFileSync(resultFile, `${JSON.stringify({
+    schemaVersion: 1,
+    extensionSpecVersion: 1,
+    extension: { id: "zhuiyi-jira-mcp", version: "0.1.0" },
+    outputs,
+  }, null, 2)}\n`, { mode: 0o600 });
+}
+
+main().catch((error) => {
+  process.stderr.write(`${error.code ? `${error.code}: ` : ""}${error.message}\n`);
+  process.exitCode = 1;
+});

package/extensions/zhuiyi-jira-mcp/0.1.0/lib/archive.js

@@ -0,0 +1,196 @@
+const crypto = require("node:crypto");
+const fs = require("node:fs");
+const https = require("node:https");
+const path = require("node:path");
+const zlib = require("node:zlib");
+
+function archiveError(code, message, details = {}) {
+  return Object.assign(new Error(message), { code, details });
+}
+
+function safeRelativePath(value) {
+  const normalized = String(value || "").replace(/\\/g, "/").replace(/^\.\//, "").replace(/\/$/, "");
+  if (!normalized || path.posix.isAbsolute(normalized) || normalized.split("/").some((part) => !part || part === "." || part === "..")) {
+    throw archiveError("JIRA_ARCHIVE_UNSAFE", `Unsafe archive path: ${value || "<empty>"}`, { path: value || null });
+  }
+  return normalized;
+}
+
+function tarString(buffer, start, length) {
+  return buffer.subarray(start, start + length).toString("utf8").replace(/\0.*$/s, "").trim();
+}
+
+function tarNumber(buffer, start, length) {
+  const value = tarString(buffer, start, length).replace(/^0+/, "") || "0";
+  if (!/^[0-7]+$/.test(value)) throw archiveError("JIRA_ARCHIVE_INVALID", `Invalid tar numeric field: ${value}`);
+  return Number.parseInt(value, 8);
+}
+
+function parsePax(content) {
+  const values = {};
+  let offset = 0;
+  while (offset < content.length) {
+    const space = content.indexOf(0x20, offset);
+    if (space < 0) throw archiveError("JIRA_ARCHIVE_INVALID", "Invalid PAX record length");
+    const length = Number(content.subarray(offset, space).toString("ascii"));
+    if (!Number.isInteger(length) || length <= 0 || offset + length > content.length) throw archiveError("JIRA_ARCHIVE_INVALID", "Invalid PAX record");
+    const record = content.subarray(space + 1, offset + length - 1).toString("utf8");
+    const equal = record.indexOf("=");
+    if (equal > 0) values[record.slice(0, equal)] = record.slice(equal + 1);
+    offset += length;
+  }
+  return values;
+}
+
+function assertTarChecksum(buffer, offset) {
+  const expected = tarNumber(buffer, offset + 148, 8);
+  let actual = 0;
+  for (let index = 0; index < 512; index += 1) actual += index >= 148 && index < 156 ? 0x20 : buffer[offset + index];
+  if (actual !== expected) throw archiveError("JIRA_ARCHIVE_INVALID", "Tar header checksum mismatch");
+}
+
+function extractTarGz(archiveFile, outputRoot, options) {
+  let tar;
+  try {
+    tar = zlib.gunzipSync(fs.readFileSync(archiveFile), { maxOutputLength: options.maxExtractBytes + 1024 * 1024 });
+  } catch (error) {
+    if (error.code === "ERR_BUFFER_TOO_LARGE" || /larger than/.test(error.message)) throw archiveError("JIRA_ARCHIVE_TOO_LARGE", `Archive expands beyond ${options.maxExtractBytes} bytes`, { limit: options.maxExtractBytes });
+    throw archiveError("JIRA_ARCHIVE_INVALID", `Cannot decompress tar.gz archive: ${error.message}`);
+  }
+  fs.mkdirSync(outputRoot, { recursive: true });
+  const seen = new Set();
+  let files = 0;
+  let extractedBytes = 0;
+  let offset = 0;
+  let pax = {};
+  let longPath = null;
+  const links = [];
+  while (offset + 512 <= tar.length) {
+    const header = tar.subarray(offset, offset + 512);
+    if (header.every((byte) => byte === 0)) break;
+    assertTarChecksum(tar, offset);
+    const type = String.fromCharCode(header[156] || 0x30);
+    const size = tarNumber(tar, offset + 124, 12);
+    const mode = tarNumber(tar, offset + 100, 8);
+    const prefix = tarString(tar, offset + 345, 155);
+    const rawName = tarString(tar, offset, 100);
+    let name = longPath || pax.path || (prefix ? `${prefix}/${rawName}` : rawName);
+    longPath = null;
+    pax = {};
+    const contentStart = offset + 512;
+    const contentEnd = contentStart + size;
+    if (contentEnd > tar.length) throw archiveError("JIRA_ARCHIVE_INVALID", "Truncated tar entry");
+    const content = tar.subarray(contentStart, contentEnd);
+    offset = contentStart + Math.ceil(size / 512) * 512;
+    if (type === "x") {
+      pax = parsePax(content);
+      continue;
+    }
+    if (type === "L") {
+      longPath = content.toString("utf8").replace(/\0.*$/s, "").trim();
+      continue;
+    }
+    if (!["0", "\0", "5", "2"].includes(type)) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Unsupported tar entry type ${JSON.stringify(type)} for ${name}`, { path: name, type });
+    name = safeRelativePath(name);
+    const rootPrefix = `${options.root}/`;
+    if (name !== options.root && !name.startsWith(rootPrefix)) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Archive entry is outside expected root ${options.root}: ${name}`, { path: name, root: options.root });
+    const relative = name === options.root ? "" : name.slice(rootPrefix.length);
+    if (!relative) {
+      if (type !== "5") throw archiveError("JIRA_ARCHIVE_UNSAFE", `Archive root must be a directory: ${name}`, { path: name });
+      continue;
+    }
+    const safe = safeRelativePath(relative);
+    if (seen.has(safe)) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Duplicate archive path: ${safe}`, { path: safe });
+    seen.add(safe);
+    files += 1;
+    if (files > options.maxFiles) throw archiveError("JIRA_ARCHIVE_TOO_LARGE", `Archive contains more than ${options.maxFiles} entries`, { limit: options.maxFiles });
+    extractedBytes += type === "5" || type === "2" ? 0 : size;
+    if (extractedBytes > options.maxExtractBytes) throw archiveError("JIRA_ARCHIVE_TOO_LARGE", `Archive expands beyond ${options.maxExtractBytes} bytes`, { limit: options.maxExtractBytes });
+    const target = path.join(outputRoot, ...safe.split("/"));
+    if (!target.startsWith(`${path.resolve(outputRoot)}${path.sep}`)) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Archive path escapes output: ${safe}`, { path: safe });
+    if (type === "5") fs.mkdirSync(target, { recursive: true, mode: mode & 0o777 });
+    else if (type === "2") {
+      const linkName = tarString(header, 157, 100);
+      if (!linkName || path.posix.isAbsolute(linkName)) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Unsafe symbolic link target for ${safe}`, { path: safe, link: linkName });
+      links.push({ safe, target, linkName, mode: mode & 0o777 });
+    } else {
+      fs.mkdirSync(path.dirname(target), { recursive: true });
+      fs.writeFileSync(target, content, { mode: mode & 0o777 });
+    }
+  }
+  for (const link of links) {
+    const resolvedRelative = path.posix.normalize(path.posix.join(path.posix.dirname(link.safe), link.linkName));
+    if (resolvedRelative === ".." || resolvedRelative.startsWith("../") || path.posix.isAbsolute(resolvedRelative)) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Symbolic link escapes archive root: ${link.safe}`, { path: link.safe, link: link.linkName });
+    const source = path.join(outputRoot, ...resolvedRelative.split("/"));
+    if (!fs.existsSync(source) || !fs.lstatSync(source).isFile() || fs.lstatSync(source).isSymbolicLink()) throw archiveError("JIRA_ARCHIVE_UNSAFE", `Symbolic link does not resolve to a regular archive file: ${link.safe}`, { path: link.safe, link: link.linkName });
+    fs.mkdirSync(path.dirname(link.target), { recursive: true });
+    fs.copyFileSync(source, link.target);
+    fs.chmodSync(link.target, link.mode);
+    extractedBytes += fs.statSync(link.target).size;
+    if (extractedBytes > options.maxExtractBytes) throw archiveError("JIRA_ARCHIVE_TOO_LARGE", `Archive expands beyond ${options.maxExtractBytes} bytes`, { limit: options.maxExtractBytes });
+  }
+  return { files, extractedBytes };
+}
+
+function validatePackage(outputRoot, release) {
+  const packageFile = path.join(outputRoot, "package.json");
+  let value;
+  try { value = JSON.parse(fs.readFileSync(packageFile, "utf8")); } catch (error) { throw archiveError("JIRA_PACKAGE_INVALID", `Cannot read extracted package.json: ${error.message}`, { file: packageFile }); }
+  if (value.name !== release.package.name || value.version !== release.package.version) {
+    throw archiveError("JIRA_PACKAGE_INVALID", `Extracted package identity mismatch: expected ${release.package.name}@${release.package.version}`, { expected: release.package, actual: { name: value.name, version: value.version } });
+  }
+  const entry = path.join(outputRoot, ...release.entry.split("/"));
+  if (!fs.existsSync(entry) || !fs.lstatSync(entry).isFile() || fs.lstatSync(entry).isSymbolicLink()) throw archiveError("JIRA_PACKAGE_INVALID", `Missing package entry: ${release.entry}`, { entry: release.entry });
+}
+
+function download(url, file, options, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) return reject(archiveError("JIRA_DOWNLOAD_FAILED", "Too many download redirects", { url }));
+    let parsed;
+    try { parsed = new URL(url); } catch { return reject(archiveError("JIRA_DOWNLOAD_FAILED", `Invalid download URL: ${url}`, { url })); }
+    if (parsed.protocol !== "https:") return reject(archiveError("JIRA_DOWNLOAD_FAILED", `Download URL must use HTTPS: ${url}`, { url }));
+    if (!Array.isArray(options.allowedHosts) || !options.allowedHosts.includes(parsed.hostname)) {
+      return reject(archiveError("JIRA_DOWNLOAD_HOST_FORBIDDEN", `Download host is not allowed: ${parsed.hostname}`, { url, host: parsed.hostname }));
+    }
+    const request = https.get(parsed, { headers: { "user-agent": "zhuiyi-jira-mcp-extension/0.1.0" } }, (response) => {
+      if ([301, 302, 303, 307, 308].includes(response.statusCode) && response.headers.location) {
+        response.resume();
+        return download(new URL(response.headers.location, parsed).href, file, options, redirects + 1).then(resolve, reject);
+      }
+      if (response.statusCode !== 200) {
+        response.resume();
+        return reject(archiveError("JIRA_DOWNLOAD_FAILED", `Download returned HTTP ${response.statusCode}`, { url, statusCode: response.statusCode }));
+      }
+      const declared = Number(response.headers["content-length"] || 0);
+      if (declared > options.maxDownloadBytes) {
+        response.resume();
+        return reject(archiveError("JIRA_DOWNLOAD_TOO_LARGE", `Download exceeds ${options.maxDownloadBytes} bytes`, { url, limit: options.maxDownloadBytes, actual: declared }));
+      }
+      const stream = fs.createWriteStream(file, { flags: "wx", mode: 0o600 });
+      const hash = crypto.createHash("sha256");
+      let bytes = 0;
+      response.on("data", (chunk) => {
+        bytes += chunk.length;
+        if (bytes > options.maxDownloadBytes) request.destroy(archiveError("JIRA_DOWNLOAD_TOO_LARGE", `Download exceeds ${options.maxDownloadBytes} bytes`, { url, limit: options.maxDownloadBytes, actual: bytes }));
+        else hash.update(chunk);
+      });
+      response.pipe(stream);
+      stream.on("finish", () => stream.close(() => resolve({ bytes, sha256: hash.digest("hex"), finalUrl: parsed.href })));
+      stream.on("error", reject);
+    });
+    request.setTimeout(options.downloadTimeoutMs, () => request.destroy(archiveError("JIRA_DOWNLOAD_TIMEOUT", `Download timed out after ${options.downloadTimeoutMs}ms`, { url, timeoutMs: options.downloadTimeoutMs })));
+    request.on("error", (error) => reject(error.code?.startsWith("JIRA_") ? error : archiveError("JIRA_DOWNLOAD_FAILED", `Download failed: ${error.message}`, { url })));
+  });
+}
+
+async function prepareRelease(release, outputRoot, options = {}) {
+  const archiveFile = path.join(path.dirname(outputRoot), "zhuiyi-jira-mcp.tar.gz");
+  const downloaded = options.downloaded || await download(release.url, archiveFile, release);
+  if (downloaded.sha256 !== release.sha256) throw archiveError("JIRA_ARCHIVE_HASH_MISMATCH", `Archive hash mismatch for ${release.url}`, { url: release.url, expectedSha256: release.sha256, actualSha256: downloaded.sha256 });
+  const source = options.archiveFile || archiveFile;
+  const extracted = extractTarGz(source, outputRoot, release);
+  validatePackage(outputRoot, release);
+  return { ...downloaded, ...extracted };
+}
+
+module.exports = { archiveError, download, extractTarGz, prepareRelease, safeRelativePath, validatePackage };

package/extensions/zhuiyi-jira-mcp/0.1.0/manifest.json

@@ -0,0 +1,38 @@
+{
+  "schemaVersion": 3,
+  "extensionSpecVersion": 1,
+  "experimental": true,
+  "id": "zhuiyi-jira-mcp",
+  "name": "Zhuiyi Jira MCP",
+  "version": "0.1.0",
+  "entry": "init.js",
+  "entrySha256": "af7f4a71835402235b3d763418ee1b4135da0125a85aff1153bfaa0f6c83a022",
+  "timeoutMs": 120000,
+  "capabilities": {
+    "networkHosts": ["gitee.com", "raw.giteeusercontent.com"]
+  },
+  "outputs": [
+    {
+      "id": "runtime",
+      "kind": "directory",
+      "ownership": "exclusive",
+      "target": ".code-workspace/extensions/zhuiyi-jira-mcp/0.1.0"
+    },
+    {
+      "id": "codex-config",
+      "kind": "text-block",
+      "ownership": "shared",
+      "target": ".codex/config.toml",
+      "format": "toml",
+      "tools": ["codex"]
+    },
+    {
+      "id": "claude-config",
+      "kind": "json-member",
+      "ownership": "shared",
+      "target": ".mcp.json",
+      "selector": "/mcpServers/zhuiyi-jira",
+      "tools": ["claude"]
+    }
+  ]
+}

package/extensions/zhuiyi-jira-mcp/0.1.0/release.json

@@ -0,0 +1,15 @@
+{
+  "url": "https://gitee.com/liutaigang/zhuiyi-jira-mcp/raw/master/release/zhuiyi-jira-mcp-0.1.0.tar.gz",
+  "allowedHosts": ["gitee.com", "raw.giteeusercontent.com"],
+  "sha256": "74785207a75d1f7ea74ea893533835720baed016509ef4401c9b20f3b59a4afa",
+  "root": "zhuiyi-jira-mcp-0.1.0",
+  "entry": "dist/index.js",
+  "package": {
+    "name": "zhuiyi-jira-mcp",
+    "version": "0.1.0"
+  },
+  "maxDownloadBytes": 20971520,
+  "maxExtractBytes": 104857600,
+  "maxFiles": 10000,
+  "downloadTimeoutMs": 60000
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "code-workspace-zhuiyi",
+  "version": "0.1.0-beta.1",
+  "description": "Local multi-project registry and safety layer for AI coding workspaces",
+  "author": "icebearx-ai",
+  "license": "MIT",
+  "main": "src/index.js",
+  "exports": {
+    ".": "./src/index.js"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bin": {
+    "code-workspace": "bin/code-workspace.js",
+    "code-w": "bin/code-workspace.js"
+  },
+  "files": [
+    "assets",
+    "bin",
+    "src/cli.js",
+    "src/cli",
+    "src/index.js",
+    "src/core",
+    "src/i18n",
+    "src/init",
+    "src/monitor",
+    "artifacts",
+    "extensions",
+    "docs/extension-architecture.zh-CN.md",
+    "spec",
+    "docs/extensions.md",
+    "docs/extensions.zh-CN.md",
+    "schemas",
+    ".env.example",
+    "README.md",
+    "README.zh-CN.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "scripts": {
+    "test": "node --test src/__test__/*.test.js",
+    "dev:monitor": "node bin/code-workspace.js monitor",
+    "check": "npm test && npm run cli:architecture-check && npm run pack:check",
+    "cli:architecture-check": "node scripts/check-cli-architecture.js",
+    "pack:check": "npm pack --dry-run",
+    "cli": "node bin/code-workspace.js",
+    "prepublishOnly": "npm run check"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "@iarna/toml": "^2.2.5",
+    "js-yaml": "^5.2.2",
+    "proper-lockfile": "^4.1.2"
+  }
+}

package/schemas/extension-init-context-v1.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://icebearx.ai/code-workspace/extension-init-context-v1.json",
+  "title": "Code Workspace extension init context v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "extensionSpecVersion", "extension", "workspace", "tools"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "extensionSpecVersion": { "const": 1 },
+    "extension": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "version"],
+      "properties": {
+        "id": { "$ref": "#/$defs/id" },
+        "version": { "type": "string", "minLength": 1 }
+      }
+    },
+    "workspace": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["name", "uuid", "language"],
+      "properties": {
+        "name": { "type": "string", "minLength": 1 },
+        "uuid": { "type": "string", "minLength": 1 },
+        "language": { "type": "string", "minLength": 1 }
+      }
+    },
+    "tools": {
+      "type": "array",
+      "uniqueItems": true,
+      "items": { "enum": ["claude", "codex"] }
+    }
+  },
+  "$defs": {
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" }
+  }
+}

package/schemas/extension-init-result-v1.json

@@ -0,0 +1,42 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://icebearx.ai/code-workspace/extension-init-result-v1.json",
+  "title": "Code Workspace extension init result v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "extensionSpecVersion", "extension", "outputs"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "extensionSpecVersion": { "const": 1 },
+    "extension": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": ["id", "version"],
+      "properties": {
+        "id": { "$ref": "#/$defs/id" },
+        "version": { "type": "string", "minLength": 1 }
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "source"],
+        "properties": {
+          "id": { "$ref": "#/$defs/id" },
+          "source": { "$ref": "#/$defs/relativePath" }
+        }
+      }
+    }
+  },
+  "$defs": {
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+    "relativePath": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^(?!/)(?!.*\\\\)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*//).+$"
+    }
+  }
+}

package/schemas/extension-manifest-v1.json

@@ -0,0 +1,55 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://icebearx.ai/code-workspace/extension-manifest-v1.json",
+  "title": "Code Workspace built-in extension manifest v1",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "experimental", "id", "name", "version", "entry", "entrySha256", "codeWorkspace", "timeoutMs", "artifacts"],
+  "properties": {
+    "schemaVersion": { "const": 1 },
+    "experimental": { "const": true },
+    "id": { "$ref": "#/$defs/id" },
+    "name": { "type": "string", "minLength": 1, "maxLength": 100 },
+    "version": { "type": "string" },
+    "entry": { "const": "init.js" },
+    "entrySha256": { "$ref": "#/$defs/sha256" },
+    "codeWorkspace": { "type": "string", "minLength": 1 },
+    "timeoutMs": { "type": "integer", "minimum": 1, "maximum": 300000 },
+    "artifacts": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "kind", "sha256"],
+        "properties": {
+          "id": { "$ref": "#/$defs/id" },
+          "kind": { "enum": ["file", "codex-config-block", "codex-hooks"] },
+          "target": { "type": "string", "minLength": 1 },
+          "output": { "type": "string", "minLength": 1 },
+          "sha256": { "$ref": "#/$defs/sha256" },
+          "tools": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true,
+            "items": { "enum": ["claude", "codex"] }
+          }
+        },
+        "allOf": [
+          {
+            "if": { "properties": { "kind": { "const": "file" } } },
+            "then": { "required": ["target"] }
+          },
+          {
+            "if": { "properties": { "kind": { "enum": ["codex-config-block", "codex-hooks"] } } },
+            "then": { "required": ["output"] }
+          }
+        ]
+      }
+    }
+  },
+  "$defs": {
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+    "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" }
+  }
+}

package/schemas/extension-manifest-v2.json

@@ -0,0 +1,84 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://icebearx.ai/code-workspace/extension-manifest-v2.json",
+  "title": "Code Workspace built-in extension manifest v2",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schemaVersion", "experimental", "id", "name", "version", "entry", "entrySha256", "codeWorkspace", "timeoutMs", "outputs"],
+  "properties": {
+    "schemaVersion": { "const": 2 },
+    "experimental": { "const": true },
+    "id": { "$ref": "#/$defs/id" },
+    "name": { "type": "string", "minLength": 1, "maxLength": 100 },
+    "version": { "type": "string" },
+    "entry": { "const": "init.js" },
+    "entrySha256": { "$ref": "#/$defs/sha256" },
+    "codeWorkspace": { "type": "string", "minLength": 1 },
+    "timeoutMs": { "type": "integer", "minimum": 1, "maximum": 300000 },
+    "capabilities": {
+      "type": "object",
+      "additionalProperties": false,
+      "properties": {
+        "networkHosts": {
+          "type": "array",
+          "minItems": 1,
+          "uniqueItems": true,
+          "items": { "$ref": "#/$defs/hostname" }
+        }
+      }
+    },
+    "outputs": {
+      "type": "array",
+      "minItems": 1,
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "kind", "ownership", "target"],
+        "properties": {
+          "id": { "$ref": "#/$defs/id" },
+          "kind": { "enum": ["file", "directory", "text-block", "json-member"] },
+          "ownership": { "enum": ["exclusive", "shared"] },
+          "target": { "$ref": "#/$defs/relativePath" },
+          "selector": { "type": "string", "pattern": "^/(?:[^~/]|~[01])+(?:/(?:[^~/]|~[01])+)*$" },
+          "format": { "enum": ["text", "toml"] },
+          "tools": {
+            "type": "array",
+            "minItems": 1,
+            "uniqueItems": true,
+            "items": { "enum": ["claude", "codex"] }
+          }
+        },
+        "allOf": [
+          {
+            "if": { "properties": { "kind": { "enum": ["file", "directory"] } } },
+            "then": { "properties": { "ownership": { "const": "exclusive" } } }
+          },
+          {
+            "if": { "properties": { "kind": { "enum": ["text-block", "json-member"] } } },
+            "then": { "properties": { "ownership": { "const": "shared" } } }
+          },
+          {
+            "if": { "properties": { "kind": { "const": "json-member" } } },
+            "then": { "required": ["selector"] },
+            "else": { "properties": { "selector": false } }
+          },
+          {
+            "if": { "properties": { "kind": { "const": "text-block" } } },
+            "then": { "properties": { "format": { "enum": ["text", "toml"] } } },
+            "else": { "properties": { "format": false } }
+          }
+        ]
+      }
+    }
+  },
+  "$defs": {
+    "id": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+    "sha256": { "type": "string", "pattern": "^[a-f0-9]{64}$" },
+    "hostname": { "type": "string", "pattern": "^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9.-]*[A-Za-z0-9])?$" },
+    "relativePath": {
+      "type": "string",
+      "minLength": 1,
+      "pattern": "^(?!/)(?!.*\\\\)(?!.*(?:^|/)\\.{1,2}(?:/|$))(?!.*//).+$"
+    }
+  }
+}