draftgo-cli 1.0.4 → 1.0.6

package/src/mcp/hosts.js

@@ -22,6 +22,7 @@ const HOSTS = Object.freeze([
   { name: 'gemini', displayName: 'Gemini CLI', path: '.gemini/settings.json', format: 'jsonc', registry: 'mcpServers', signals: ['.gemini'] },
   { name: 'kiro', displayName: 'Kiro', path: '.kiro/settings/mcp.json', format: 'jsonc', registry: 'mcpServers', signals: ['.kiro'] },
   { name: 'copilot', aliases: ['github-copilot'], displayName: 'GitHub Copilot', path: '.vscode/mcp.json', format: 'jsonc', registry: 'servers', vscode: true, signals: ['.vscode', '.github/prompts', '.github/copilot-instructions.md'] },
+  { name: 'zcode', displayName: 'ZCode', path: '.zcode/config.json', format: 'jsonc', registry: 'mcp.servers', vscode: true, signals: ['.zcode'] },
   { name: 'windsurf', displayName: 'Windsurf', supported: false, reason: 'Windsurf has no supported project-level MCP configuration adapter.', signals: ['.windsurf'] },
   { name: 'antigravity', displayName: 'Antigravity', supported: false, reason: 'Antigravity has no supported project-level MCP configuration adapter.', signals: ['.agent'] },
 ]);
@@ -249,41 +250,85 @@ function insertObjectProperty(source, open, close, key, value, newline) {
   );
 }
 
+function registryPath(registry) {
+  return String(registry || '').split('.').map((part) => part.trim()).filter(Boolean);
+}
+
+function nestedValue(value, keys) {
+  let current = value;
+  for (const key of keys) {
+    if (!current || typeof current !== 'object' || Array.isArray(current) || !Object.prototype.hasOwnProperty.call(current, key)) {
+      return undefined;
+    }
+    current = current[key];
+  }
+  return current;
+}
+
+function assertRegistryObjects(parsed, keys, file) {
+  let current = parsed;
+  for (let index = 0; index < keys.length; index += 1) {
+    const key = keys[index];
+    if (current[key] === undefined) return;
+    if (!current[key] || typeof current[key] !== 'object' || Array.isArray(current[key])) {
+      throw new Error(`Invalid ${file}: ${keys.slice(0, index + 1).join('.')} must be an object.`);
+    }
+    current = current[key];
+  }
+}
+
+function findNestedObject(source, open, close, keys) {
+  let currentOpen = open;
+  let currentClose = close;
+  let matched = 0;
+  for (const key of keys) {
+    const property = objectProperties(source, currentOpen, currentClose).find((item) => item.key === key);
+    if (!property) break;
+    currentOpen = property.valueStart;
+    currentClose = scanComposite(source, currentOpen) - 1;
+    matched += 1;
+  }
+  return { open: currentOpen, close: currentClose, matched };
+}
+
+function upsertDraftGoEntry(source, open, close, entry, newline) {
+  const serverProperties = objectProperties(source, open, close);
+  const draftgo = serverProperties.find((item) => item.key === 'draftgo');
+  if (draftgo) {
+    const indent = lineIndent(source, draftgo.propertyStart);
+    return replaceRange(
+      source,
+      draftgo.valueStart,
+      draftgo.valueEnd,
+      formatJsonValue(entry, indent, newline),
+    );
+  }
+  return insertObjectProperty(source, open, close, 'draftgo', entry, newline);
+}
+
 function mergeJsoncConfig(source, registry, entry, file = 'MCP config') {
+  const keys = registryPath(registry);
+  if (!keys.length) throw new Error(`Invalid ${file}: MCP registry path is missing.`);
   const initial = source.trim() ? source : '{\n}\n';
   const parsed = parseJsonc(initial, file);
-  if (parsed[registry] !== undefined
-      && (!parsed[registry] || typeof parsed[registry] !== 'object' || Array.isArray(parsed[registry]))) {
-    throw new Error(`Invalid ${file}: ${registry} must be an object.`);
-  }
+  assertRegistryObjects(parsed, keys, file);
 
   const newline = initial.includes('\r\n') ? '\r\n' : '\n';
   const rootOffset = initial.charCodeAt(0) === 0xfeff ? 1 : 0;
   const rootOpen = skipTrivia(initial, rootOffset);
   const rootEnd = scanComposite(initial, rootOpen);
   const rootClose = rootEnd - 1;
-  const rootProperties = objectProperties(initial, rootOpen, rootClose);
-  const registryProperty = rootProperties.find((item) => item.key === registry);
+  const nested = findNestedObject(initial, rootOpen, rootClose, keys);
   let result;
 
-  if (!registryProperty) {
-    result = insertObjectProperty(initial, rootOpen, rootClose, registry, { draftgo: entry }, newline);
+  if (nested.matched === keys.length) {
+    result = upsertDraftGoEntry(initial, nested.open, nested.close, entry, newline);
   } else {
-    const registryOpen = registryProperty.valueStart;
-    const registryClose = scanComposite(initial, registryOpen) - 1;
-    const serverProperties = objectProperties(initial, registryOpen, registryClose);
-    const draftgo = serverProperties.find((item) => item.key === 'draftgo');
-    if (draftgo) {
-      const indent = lineIndent(initial, draftgo.propertyStart);
-      result = replaceRange(
-        initial,
-        draftgo.valueStart,
-        draftgo.valueEnd,
-        formatJsonValue(entry, indent, newline),
-      );
-    } else {
-      result = insertObjectProperty(initial, registryOpen, registryClose, 'draftgo', entry, newline);
+    let value = { draftgo: entry };
+    for (let index = keys.length - 1; index > nested.matched; index -= 1) {
+      value = { [keys[index]]: value };
     }
+    result = insertObjectProperty(initial, nested.open, nested.close, keys[nested.matched], value, newline);
   }
 
   parseJsonc(result, file);
@@ -482,7 +527,7 @@ function statusHost(projectDir, target) {
   if (host.format === 'toml') return { host, supported: true, path: file, ...codexStatus(source) };
   try {
     const value = parseJsonc(source, host.path);
-    const registry = value[host.registry];
+    const registry = nestedValue(value, registryPath(host.registry));
     const entry = registry && typeof registry === 'object' && !Array.isArray(registry)
       ? registry.draftgo
       : undefined;

package/src/platforms.js

@@ -79,10 +79,13 @@ const platforms = [
   {
     name: 'codex',
     displayName: 'Codex CLI',
-    mainFile: '.codex/skills/draftgo/SKILL.md',
-    assetDir: '.codex/skills/draftgo',
-    skillDir: '.codex/skills/draftgo',
+    // Repo-level Codex skills now follow the Agent Skills path.
+    // MCP config still lives in .codex/config.toml, so detection stays on .codex.
+    mainFile: '.agents/skills/draftgo/SKILL.md',
+    assetDir: '.agents/skills/draftgo',
+    skillDir: '.agents/skills/draftgo',
     signals: ['.codex'],
+    legacyAssetDirs: ['.codex/skills/draftgo'],
     frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
   },
   {
@@ -100,7 +103,16 @@ const platforms = [
     mainFile: '.agents/skills/draftgo/SKILL.md',
     assetDir: '.agents/skills/draftgo',
     skillDir: '.agents/skills/draftgo',
-    signals: ['.agents/skills', '.pi'],
+    signals: ['.pi'],
+    frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
+  },
+  {
+    name: 'zcode',
+    displayName: 'ZCode',
+    mainFile: '.zcode/skills/draftgo/SKILL.md',
+    assetDir: '.zcode/skills/draftgo',
+    skillDir: '.zcode/skills/draftgo',
+    signals: ['.zcode'],
     frontmatter: { name: SKILL_NAME, description: DESCRIPTION },
   },
 ];

package/src/skill.js

@@ -193,6 +193,19 @@ function ensureRuntime(projectDir) {
   appendGitignoreLine(projectDir, '.draftgo/conflicts/');
 }
 
+function legacySkillDirs(projectDir, platform) {
+  const destAsset = path.resolve(path.join(projectDir, platform.assetDir));
+  return (platform.legacyAssetDirs || [])
+    .map((relative) => path.join(projectDir, relative))
+    .filter((absolute) => path.resolve(absolute) !== destAsset && exists(absolute));
+}
+
+function skillAlreadyInstalled(projectDir, platform) {
+  const destAsset = path.join(projectDir, platform.assetDir);
+  const destMain = path.join(projectDir, platform.mainFile);
+  return exists(destAsset) || exists(destMain) || legacySkillDirs(projectDir, platform).length > 0;
+}
+
 function installPlatform(projectDir, platform, opts = {}) {
   if (!exists(SKILL_SOURCE_DIR)) {
     throw new Error(
@@ -202,7 +215,7 @@ function installPlatform(projectDir, platform, opts = {}) {
   const destAsset = path.join(projectDir, platform.assetDir);
   const destMain  = path.join(projectDir, platform.mainFile);
   const mainOutsideAsset = path.relative(destAsset, destMain).startsWith('..');
-  if ((exists(destAsset) || exists(destMain)) && !opts.force) {
+  if (skillAlreadyInstalled(projectDir, platform) && !opts.force) {
     return { path: platform.mainFile, skipped: true };
   }
 
@@ -251,24 +264,31 @@ function installPlatform(projectDir, platform, opts = {}) {
 
   if (exists(backupAsset)) removePath(backupAsset);
   if (backupMain && exists(backupMain)) removePath(backupMain);
+  for (const legacyDir of legacySkillDirs(projectDir, platform)) removePath(legacyDir);
   if (!exists(destMain)) throw new Error(`安装后缺少入口文件：${platform.mainFile}`);
 
   return { path: platform.mainFile };
 }
 
-function uninstallPlatform(projectDir, platform) {
+function uninstallPlatform(projectDir, platform, opts = {}) {
   const destAsset = path.join(projectDir, platform.assetDir);
   const destMain  = path.join(projectDir, platform.mainFile);
   let removed = false;
-  if (exists(destAsset)) { removePath(destAsset); removed = true; }
-  if (path.relative(destAsset, destMain).startsWith('..') && exists(destMain)) {
-    removePath(destMain); removed = true;
+  if (!opts.keepSharedSkill) {
+    if (exists(destAsset)) { removePath(destAsset); removed = true; }
+    if (path.relative(destAsset, destMain).startsWith('..') && exists(destMain)) {
+      removePath(destMain); removed = true;
+    }
+  }
+  for (const legacyDir of legacySkillDirs(projectDir, platform)) {
+    removePath(legacyDir);
+    removed = true;
   }
   return removed;
 }
 
 function statusPlatform(projectDir, platform) {
-  return { installed: exists(path.join(projectDir, platform.mainFile)) };
+  return { installed: skillAlreadyInstalled(projectDir, platform) };
 }
 
 function installAll(projectDir, platforms, opts = {}) {

package/src/targets.js

@@ -14,8 +14,8 @@ function makeInstaller(p) {
     install(projectDir, opts) {
       return skill.installPlatform(projectDir, p, opts || {});
     },
-    uninstall(projectDir) {
-      return skill.uninstallPlatform(projectDir, p);
+    uninstall(projectDir, opts) {
+      return skill.uninstallPlatform(projectDir, p, opts || {});
     },
     status(projectDir) {
       return skill.statusPlatform(projectDir, p);

package/src/worktree/backend.js

@@ -1,6 +1,8 @@
 'use strict';
 
+const crypto = require('crypto');
 const fs = require('fs');
+const path = require('path');
 const { Readable } = require('stream');
 const { DraftGoMcpClient } = require('../mcp/client');
 const { BackendHttpError, WorktreeError } = require('./errors');
@@ -15,8 +17,21 @@ const FINAL_OPERATIONS = Object.freeze({
   pages: Object.freeze({ checkout: 'listPageCheckout', commit: 'updatePageCommit', contentType: 'text/html; charset=utf-8' }),
   navigations: Object.freeze({ checkout: 'listNavigationCheckout', commit: 'updateNavigationCommit', contentType: 'text/html; charset=utf-8' }),
   docs: Object.freeze({ checkout: 'listContentArticleCheckout', commit: 'updateContentArticleCommit', contentType: 'text/html; charset=utf-8', jsonCommit: true }),
+  services: Object.freeze({
+    checkout: 'listCustomServiceDraft',
+    commit: 'updateCustomServiceDraft',
+    contentType: 'text/plain; charset=utf-8',
+    jsonCommit: true,
+    commitField: 'source',
+    fileExtension: '.go',
+    sdk: 'listCustomServiceSdk',
+  }),
 });
 
+function sha256Utf8(value) {
+  return crypto.createHash('sha256').update(String(value), 'utf8').digest('hex');
+}
+
 function isObject(value) {
   return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
 }
@@ -184,29 +199,126 @@ async function finalMetadata(config, resourceType, resourceId, session, options
   if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
   const raw = await readBounded(response, MAX_CHECKOUT_JSON_BYTES, true);
   const value = parseJsonText(raw, 'DraftGo checkout endpoint');
+  if (type === 'services' && typeof value.source !== 'string') {
+    throw new WorktreeError('INVALID_BACKEND_RESPONSE', 'DraftGo service draft did not include source text.');
+  }
   const version = firstValue(value.content_version, value.revision);
-  const content = typeof value.content === 'string' ? value.content : null;
+  const sourceContent = type === 'services' ? value.source : null;
+  const content = sourceContent != null
+    ? sourceContent
+    : (typeof value.content === 'string' ? value.content : null);
   const contentURL = firstValue(value.content_url, checkoutURL);
-  const contentType = type === 'docs' ? spec.contentType : spec.contentType;
+  const contentType = spec.contentType;
   const size = content == null ? null : Buffer.byteLength(content, 'utf8');
+  const contentHash = sourceContent != null ? sha256Utf8(sourceContent) : value.content_hash;
+  const usesRevision = type === 'docs' || type === 'services';
   return normalizeMetadata(config, type, resourceId, {
     resource_type: type,
     resource_id: String(resourceId),
     title: value.title || '', route: value.route || null, code: value.code || null, slug: value.slug || null,
     content_type: contentType,
-    file_extension: '.html',
+    file_extension: spec.fileExtension || '.html',
     content_size: size,
-    content_hash: value.content_hash,
-    ...(type === 'docs' ? { base_revision: version } : { base_version: version }),
-    etag: value.content_hash,
+    content_hash: contentHash,
+    ...(usesRevision ? { base_revision: version } : { base_version: version }),
+    etag: contentHash,
     download_url: contentURL,
     commit_url: operationPath(config, commitOperation.path, resourceId),
     commit_method: String(commitOperation.method || 'PUT').toUpperCase(),
     inline_content: content,
     json_commit: spec.jsonCommit === true,
+    commit_field: spec.commitField || null,
   });
 }
 
+function sdkRelativePath(value) {
+  const relative = String(value || '').replace(/\\/g, '/').replace(/^\/+/, '');
+  if (!relative || relative.includes('\0') || relative.split('/').some((part) => part === '' || part === '.' || part === '..')) {
+    throw new WorktreeError('UNSAFE_SDK_PATH', 'DraftGo SDK bundle included an unsafe relative path.', { path: value });
+  }
+  return relative;
+}
+
+async function syncSDK(config, session, projectDir, options = {}) {
+  const { registryRevision, describeOperation } = require('../commands/api');
+  const { TOOL_NAMES, openToolSession, callStructured } = require('../mcp/tools');
+  const spec = FINAL_OPERATIONS.services;
+  const sdkDir = path.join(projectDir, '.draftgo', 'worktree', 'sdk');
+  let apiSession;
+  try {
+    apiSession = session && session.names && session.names[TOOL_NAMES.apiCall]
+      ? session
+      : await openToolSession(config, [
+        TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+      ], {
+        ...options,
+        client: (session && session.client) || options.client,
+        tools: (session && session.tools) || options.tools,
+        clientInitialized: true,
+      });
+  } catch (error) {
+    throw new WorktreeError(
+      'SDK_CHECKOUT_FAILED',
+      `Unable to open an API session for the Go SDK bundle: ${error.message}`,
+    );
+  }
+  let revision;
+  let described;
+  try {
+    revision = await registryRevision(apiSession, spec.sdk);
+    described = await describeOperation(projectDir || process.cwd(), config, apiSession, spec.sdk, revision);
+  } catch (error) {
+    throw new WorktreeError(
+      'SDK_CHECKOUT_FAILED',
+      `Unable to describe the Go SDK bundle (${spec.sdk}): ${error.message}`,
+    );
+  }
+  const operation = described && described.operation || {};
+  const invoke = await callStructured(apiSession, TOOL_NAMES.apiCall, {
+    operation_id: spec.sdk,
+    registry_revision: revision,
+  }, options);
+  const workflow = invoke && invoke.workflow || {};
+  if (workflow.required !== true || workflow.workflow !== 'checkout_commit') {
+    throw new WorktreeError('INVALID_WORKFLOW_DESCRIPTOR', 'DraftGo did not return a checkout/commit workflow descriptor for the Go SDK bundle.');
+  }
+  const sdkURL = operationPath(config, operation.path || workflow.path, '');
+  const response = await (options.fetch || fetch)(sdkURL, {
+    method: String(operation.method || 'GET').toUpperCase(),
+    headers: authHeaders(config, { Accept: 'application/json' }),
+    signal: options.signal,
+    redirect: 'error',
+  });
+  if (!response.ok) {
+    const httpError = await errorForResponse(response, config.token || config.sat);
+    throw new WorktreeError(
+      'SDK_CHECKOUT_FAILED',
+      `Unable to download the Go SDK bundle: ${httpError.message}`,
+      { status: httpError.status, code: httpError.code },
+    );
+  }
+  const raw = await readBounded(response, MAX_CHECKOUT_JSON_BYTES, true);
+  const value = parseJsonText(raw, 'DraftGo SDK endpoint');
+  const files = isObject(value.files) ? value.files : null;
+  if (!files || !Object.keys(files).length) {
+    throw new WorktreeError('SDK_CHECKOUT_FAILED', 'DraftGo SDK bundle did not include any files.');
+  }
+  await fs.promises.rm(sdkDir, { recursive: true, force: true });
+  await fs.promises.mkdir(sdkDir, { recursive: true });
+  for (const [relative, content] of Object.entries(files)) {
+    const safe = sdkRelativePath(relative);
+    const destination = path.join(sdkDir, ...safe.split('/'));
+    if (typeof content !== 'string') {
+      throw new WorktreeError('SDK_CHECKOUT_FAILED', `DraftGo SDK file ${safe} is not text.`);
+    }
+    await fs.promises.mkdir(path.dirname(destination), { recursive: true });
+    await fs.promises.writeFile(destination, content, 'utf8');
+  }
+  const contentHash = firstValue(value.content_hash, sha256Utf8(JSON.stringify(files)));
+  await fs.promises.writeFile(path.join(sdkDir, '.hash'), `${contentHash}\n`, 'utf8');
+  return { directory: sdkDir, content_hash: contentHash };
+}
+
 function normalizeUrl(config, value, purpose) {
   if (!value) return null;
   let url;
@@ -281,8 +393,16 @@ function normalizeMetadata(config, resourceType, resourceId, payload) {
 
 async function resolveMetadata(config, resourceType, resourceId, options = {}) {
   if (options.metadata) return normalizeMetadata(config, resourceType, resourceId, options.metadata);
+  const type = canonicalResourceType(resourceType);
   const client = options.client || new DraftGoMcpClient(config);
   if (!options.clientInitialized) await client.initialize(options);
+  if (type === 'services') {
+    const { TOOL_NAMES, openToolSession } = require('../mcp/tools');
+    const session = await openToolSession(config, [
+      TOOL_NAMES.apiSearch, TOOL_NAMES.apiDescribe, TOOL_NAMES.apiCall,
+    ], { ...options, client });
+    return finalMetadata(config, type, resourceId, session, options);
+  }
   let toolName = METADATA_TOOL;
   if (typeof client.listAllTools === 'function') {
     const tools = options.tools || await client.listAllTools(options);
@@ -382,21 +502,29 @@ async function commit(config, metadata, localPath, current, options = {}) {
     'Content-Length': String(current.size),
     'X-Content-SHA256': current.hash,
   });
-  if (metadata.etag) headers['If-Match'] = String(metadata.etag);
-  else if (metadata.base_version != null) headers['If-Match'] = String(metadata.base_version);
-  else if (metadata.base_revision != null) headers['If-Match'] = String(metadata.base_revision);
-  if (metadata.base_version != null) headers['DraftGo-Base-Version'] = String(metadata.base_version);
-  if (metadata.base_revision != null) headers['DraftGo-Base-Revision'] = String(metadata.base_revision);
-
   let body;
   let duplex;
-  if (metadata.raw && metadata.raw.json_commit === true) {
-    const content = fs.readFileSync(localPath, 'utf8');
-    body = JSON.stringify({
-      content,
-      ...(metadata.base_revision != null ? { base_revision: metadata.base_revision } : {}),
-      ...(metadata.base_revision == null && metadata.content_hash ? { base_hash: metadata.content_hash } : {}),
-    });
+  const raw = metadata.raw && typeof metadata.raw === 'object' ? metadata.raw : {};
+  const commitField = raw.commitField || raw.commit_field || null;
+  if (commitField !== 'source') {
+    if (metadata.etag) headers['If-Match'] = String(metadata.etag);
+    else if (metadata.base_version != null) headers['If-Match'] = String(metadata.base_version);
+    else if (metadata.base_revision != null) headers['If-Match'] = String(metadata.base_revision);
+  }
+  if (metadata.base_version != null) headers['DraftGo-Base-Version'] = String(metadata.base_version);
+  if (metadata.base_revision != null) headers['DraftGo-Base-Revision'] = String(metadata.base_revision);
+  if (raw.json_commit === true) {
+    const fileContents = fs.readFileSync(localPath, 'utf8');
+    body = JSON.stringify(commitField === 'source'
+      ? {
+        source: fileContents,
+        ...(metadata.base_revision != null ? { base_revision: metadata.base_revision } : {}),
+      }
+      : {
+        content: fileContents,
+        ...(metadata.base_revision != null ? { base_revision: metadata.base_revision } : {}),
+        ...(metadata.base_revision == null && metadata.content_hash ? { base_hash: metadata.content_hash } : {}),
+      });
     headers['Content-Type'] = 'application/json';
     headers['Content-Length'] = String(Buffer.byteLength(body, 'utf8'));
   } else {
@@ -413,8 +541,14 @@ async function commit(config, metadata, localPath, current, options = {}) {
   });
   if (!response.ok) throw await errorForResponse(response, config.token || config.sat);
   const text = await readBounded(response, MAX_JSON_BYTES, true);
-  if (!text.trim()) return {};
-  return parseJsonText(text, 'DraftGo commit endpoint');
+  if (!text.trim()) {
+    return commitField === 'source' ? { content_hash: current.hash } : {};
+  }
+  const payload = parseJsonText(text, 'DraftGo commit endpoint');
+  if (commitField === 'source') {
+    return { ...payload, content_hash: current.hash };
+  }
+  return payload;
 }
 
 function nodeReadable(response) {
@@ -424,6 +558,7 @@ function nodeReadable(response) {
 
 module.exports = {
   METADATA_TOOL,
+  FINAL_OPERATIONS,
   readBounded,
   MAX_CHECKOUT_JSON_BYTES,
   toolNameMatches,
@@ -433,6 +568,7 @@ module.exports = {
   resolveMetadata,
   download,
   commit,
+  syncSDK,
   nodeReadable,
   errorForResponse,
 };

package/src/worktree/index.js

@@ -163,6 +163,9 @@ async function checkoutResourcesUnlocked(projectDir, resourceType, resourceIds,
     return entry;
   }, { ...options, settled: true });
   const results = settled.filter((item) => item.status === 'fulfilled').map((item) => item.value);
+  if (canonical === 'services' && results.length && typeof backend.syncSDK === 'function') {
+    await backend.syncSDK(config, session, projectDir, { ...options, ...session, projectDir });
+  }
   for (const entry of results) manifest.entries[entryKey(canonical, entry.resource_id)] = entry;
   if (results.length) await saveManifest(projectDir, manifest);
   const failures = settled.filter((item) => item.status === 'rejected');

package/src/worktree/types.js

@@ -7,6 +7,7 @@ const RESOURCE_TYPES = Object.freeze({
   pages: Object.freeze({ directory: 'pages', prefix: 'page' }),
   navigations: Object.freeze({ directory: 'navigations', prefix: 'nav' }),
   docs: Object.freeze({ directory: 'docs', prefix: 'article' }),
+  services: Object.freeze({ directory: 'services', prefix: 'service' }),
 });
 
 const TYPE_ALIASES = new Map([
@@ -20,6 +21,8 @@ const TYPE_ALIASES = new Map([
   ['article', 'docs'],
   ['articles', 'docs'],
   ['docs/articles', 'docs'],
+  ['service', 'services'],
+  ['services', 'services'],
 ]);
 
 const CONTENT_EXTENSIONS = new Map([
@@ -28,6 +31,7 @@ const CONTENT_EXTENSIONS = new Map([
   ['text/markdown', '.md'],
   ['text/x-markdown', '.md'],
   ['text/plain', '.txt'],
+  ['text/x-go', '.go'],
 ]);
 
 function canonicalResourceType(value) {
@@ -36,7 +40,7 @@ function canonicalResourceType(value) {
   if (!canonical) {
     throw new WorktreeError(
       'UNSUPPORTED_RESOURCE_TYPE',
-      `Unsupported checkout resource type: ${value}. Expected pages, nav, or docs.`,
+      `Unsupported checkout resource type: ${value}. Expected pages, nav, docs, or services.`,
       { resource_type: value }
     );
   }
@@ -48,25 +52,25 @@ function mediaType(contentType) {
 }
 
 function normalizeExtension(contentType, backendExtension) {
+  if (backendExtension != null && backendExtension !== '') {
+    let extension = String(backendExtension).trim();
+    if (!extension.startsWith('.')) extension = `.${extension}`;
+    if (!/^\.[A-Za-z0-9][A-Za-z0-9._-]{0,15}$/.test(extension)) {
+      throw new WorktreeError(
+        'UNSAFE_FILE_EXTENSION',
+        'The backend returned an unsafe checkout file extension.',
+        { file_extension: backendExtension }
+      );
+    }
+    return extension.toLowerCase();
+  }
   const known = CONTENT_EXTENSIONS.get(mediaType(contentType));
   if (known) return known;
-  if (backendExtension == null || backendExtension === '') {
-    throw new WorktreeError(
-      'MISSING_FILE_EXTENSION',
-      'DraftGo must provide a safe file extension for this content type.',
-      { content_type: contentType },
-    );
-  }
-  let extension = String(backendExtension).trim();
-  if (!extension.startsWith('.')) extension = `.${extension}`;
-  if (!/^\.[A-Za-z0-9][A-Za-z0-9._-]{0,15}$/.test(extension)) {
-    throw new WorktreeError(
-      'UNSAFE_FILE_EXTENSION',
-      'The backend returned an unsafe checkout file extension.',
-      { file_extension: backendExtension }
-    );
-  }
-  return extension.toLowerCase();
+  throw new WorktreeError(
+    'MISSING_FILE_EXTENSION',
+    'DraftGo must provide a safe file extension for this content type.',
+    { content_type: contentType },
+  );
 }
 
 function safeIdSegment(value) {