@infinisys/is-devops 0.0.0-stage → 0.1.1

package/lib/gitfox-api.js

@@ -0,0 +1,600 @@
+/**
+ * Thin, dependency-free GitFox REST client used by the DevOps Host half and
+ * its single agent tool.
+ *
+ * The client never stores a token: every operation resolves the connection
+ * through `infinitySettings` so a settings save reaches the very next call.
+ */
+
+import { request as httpRequest } from 'node:http';
+import { request as httpsRequest } from 'node:https';
+
+import { DEFAULT_AGENT_ACTOR, withBotName } from './bot-identity.js';
+
+/** Error carrying an HTTP status and a stable code. */
+export class GitFoxError extends Error {
+  /**
+   * @param {string} message - human-readable detail.
+   * @param {{ status?: number, code?: string }} [options] - error metadata.
+   */
+  constructor(message, options = {}) {
+    super(message);
+    this.name = 'GitFoxError';
+    this.status = options.status ?? 0;
+    this.code = options.code ?? 'gitfox-error';
+  }
+}
+
+/**
+ * Split a `namespace/name` project reference.
+ *
+ * @param {unknown} value - user-supplied project reference.
+ * @returns {{ namespace: string, name: string }} decoded project parts.
+ * @throws {GitFoxError} when the reference is not exactly two non-empty segments.
+ */
+export function parseProject(value) {
+  const text = typeof value === 'string' ? value.trim() : '';
+  const parts = text.split('/').filter((part) => part !== '');
+  if (parts.length !== 2) {
+    throw new GitFoxError('project must use the "namespace/name" form', { code: 'invalid-project' });
+  }
+  return { namespace: parts[0], name: parts[1] };
+}
+
+/**
+ * Build the API path of one project.
+ *
+ * @param {unknown} project - `namespace/name` reference.
+ * @returns {string} encoded API path.
+ */
+export function projectPath(project) {
+  const { namespace, name } = parseProject(project);
+  return `/api/v1/projects/${encodeURIComponent(namespace)}/${encodeURIComponent(name)}`;
+}
+
+/**
+ * Append defined query parameters.
+ *
+ * @param {string} path - path with no query string.
+ * @param {Record<string, unknown>} [query] - optional parameters.
+ * @returns {string} path with a query string when any value is defined.
+ */
+export function withQuery(path, query = {}) {
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null || value === '') continue;
+    params.set(key, String(value));
+  }
+  const suffix = params.toString();
+  return suffix === '' ? path : `${path}?${suffix}`;
+}
+
+/**
+ * Resolve the attribution of one creation request. Host automation is a bot by
+ * default; an explicit `botName: null` opts out (the browser panel never uses
+ * this client, so human actions still stay human).
+ *
+ * @param {{ botName?: string | null }} options - client options.
+ * @returns {string | null} bot name or null.
+ */
+function attribution(options) {
+  return Object.hasOwn(options, 'botName') ? options.botName : DEFAULT_AGENT_ACTOR;
+}
+
+/**
+ * Read a bounded request body as bytes.
+ *
+ * @param {import('node:http').IncomingMessage} req - incoming request.
+ * @param {number} [maxBytes] - maximum accepted bytes.
+ * @returns {Promise<Buffer>} body bytes.
+ */
+export async function readRequestBody(req, maxBytes = 5 * 1024 * 1024) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of req) {
+    const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += bytes.length;
+    if (size > maxBytes) {
+      throw new GitFoxError(`request body exceeds ${maxBytes} bytes`, {
+        status: 413,
+        code: 'payload-too-large',
+      });
+    }
+    chunks.push(bytes);
+  }
+  return Buffer.concat(chunks);
+}
+
+const REQUEST_TIMEOUT_MS = 20_000;
+
+/** @returns {GitFoxError} the error raised when no token is configured. */
+function notConnectedError() {
+  return new GitFoxError(
+    'GitFox is not connected. Open Settings → Infinity System and add an access token.',
+    { status: 503, code: 'not-configured' },
+  );
+}
+
+/**
+ * @param {string} baseUrl - configured GitFox base URL.
+ * @param {string} path - API path beginning with `/api/v1/`.
+ * @returns {string} absolute request URL.
+ */
+function joinUrl(baseUrl, path) {
+  return `${baseUrl.replace(/\/+$/, '')}${path}`;
+}
+
+/**
+ * Build the abort signal, combining an optional caller signal with the timeout.
+ *
+ * @param {AbortSignal | undefined} signal - optional caller signal.
+ * @returns {AbortSignal} combined signal.
+ */
+function buildSignal(signal) {
+  const timeout = AbortSignal.timeout(REQUEST_TIMEOUT_MS);
+  if (signal === undefined) return timeout;
+  return AbortSignal.any([signal, timeout]);
+}
+
+/**
+ * @param {{ token: string }} config - resolved configuration.
+ * @param {{ method?: string, body?: unknown, signal?: AbortSignal }} options - request options.
+ * @returns {RequestInit} fetch options.
+ */
+function buildRequestOptions(config, options) {
+  const body = options.body === undefined ? undefined : JSON.stringify(options.body);
+  const headers = {
+    accept: 'application/json',
+    authorization: `Bearer ${config.token}`,
+  };
+  if (body !== undefined) {
+    headers['content-type'] = 'application/json';
+  }
+  return {
+    method: options.method ?? 'GET',
+    headers,
+    body,
+    signal: buildSignal(options.signal),
+  };
+}
+
+/** Environment variables a runtime may route outbound requests through. */
+const PROXY_VARIABLES = Object.freeze([
+  'HTTPS_PROXY',
+  'https_proxy',
+  'HTTP_PROXY',
+  'http_proxy',
+  'ALL_PROXY',
+  'all_proxy',
+]);
+
+/**
+ * The proxy configured for this process, when any.
+ *
+ * @returns {URL | undefined} proxy URL.
+ */
+function configuredProxy() {
+  for (const name of PROXY_VARIABLES) {
+    const value = process.env[name];
+    if (typeof value !== 'string' || value.trim() === '') continue;
+    try {
+      return new URL(value.trim());
+    } catch {
+      continue;
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Whether a fetch failure is a refused/unresolvable connection to the proxy.
+ *
+ * @param {unknown} error - thrown fetch error.
+ * @returns {boolean} true when retrying without the proxy is worthwhile.
+ */
+function isProxyConnectionFailure(error) {
+  if (configuredProxy() === undefined) return false;
+  const code = error instanceof Error ? error.cause?.code : undefined;
+  return code === 'ECONNREFUSED' || code === 'ENOTFOUND' || code === 'EHOSTUNREACH' || code === 'ECONNRESET';
+}
+
+/**
+ * One minimal HTTP(S) request that ignores the process proxy environment.
+ *
+ * Used only to retry a request whose proxied transport was refused; the global
+ * `fetch` keeps its configured proxy for every other caller.
+ *
+ * @param {string} url - absolute URL.
+ * @param {{ method?: string, headers?: Record<string, string>, body?: string, signal?: AbortSignal }} init - request init.
+ * @returns {Promise<{ ok: boolean, status: number, text: () => Promise<string> }>} response.
+ */
+function directFetch(url, init = {}) {
+  return new Promise((resolve, reject) => {
+    let target;
+    try {
+      target = new URL(url);
+    } catch (error) {
+      reject(error);
+      return;
+    }
+    const client = target.protocol === 'https:' ? httpsRequest : httpRequest;
+    const request = client(target, { method: init.method ?? 'GET', headers: init.headers }, (response) => {
+      const chunks = [];
+      response.on('data', (chunk) => chunks.push(chunk));
+      response.on('end', () => {
+        const text = Buffer.concat(chunks).toString('utf8');
+        resolve({
+          ok: response.statusCode !== undefined && response.statusCode >= 200 && response.statusCode < 300,
+          status: response.statusCode ?? 0,
+          text: async () => text,
+        });
+      });
+    });
+    request.on('error', reject);
+    if (init.signal !== undefined) {
+      if (init.signal.aborted) {
+        request.destroy();
+        return;
+      }
+      init.signal.addEventListener('abort', () => request.destroy(new Error('request aborted')), {
+        once: true,
+      });
+    }
+    if (init.body !== undefined) request.write(init.body);
+    request.end();
+  });
+}
+
+/**
+ * Format the failing socket address of a fetch cause.
+ *
+ * @param {any} cause - fetch error cause.
+ * @returns {string} ` (host:port)` or an empty string.
+ */
+function describeCause(cause) {
+  const address = cause?.address ?? cause?.hostname ?? cause?.host;
+  if (address === undefined) return '';
+  const port = cause?.port;
+  return ` (${address}${port === undefined || port === null ? '' : `:${port}`})`;
+}
+
+/**
+ * Hint for a request that failed on its environment proxy.
+ *
+ * @param {unknown} error - thrown fetch error.
+ * @returns {string} hint text or an empty string.
+ */
+function proxyHint(error) {
+  const proxy = configuredProxy();
+  if (proxy === undefined || !isProxyConnectionFailure(error)) return '';
+  return ` The request was routed through the proxy ${proxy.href} from the environment; start it or unset HTTPS_PROXY/HTTP_PROXY/NODE_USE_ENV_PROXY.`;
+}
+
+/**
+ * Host of the requested URL, for the error message.
+ *
+ * @param {string | undefined} url - requested URL.
+ * @returns {string} ` at host` or an empty string.
+ */
+function hostOf(url) {
+  if (url === undefined) return '';
+  try {
+    return ` at ${new URL(url).host}`;
+  } catch {
+    return '';
+  }
+}
+
+/**
+ * Translate a failed fetch into a GitFoxError, keeping the real cause.
+ *
+ * @param {unknown} error - thrown fetch error.
+ * @param {string} [url] - requested URL.
+ * @returns {GitFoxError} mapped error.
+ */
+function mapFetchError(error, url) {
+  if (error instanceof Error && error.name === 'TimeoutError') {
+    return new GitFoxError('GitFox did not answer within 20 seconds.', {
+      status: 504,
+      code: 'timeout',
+    });
+  }
+  const cause = error instanceof Error ? error.cause : undefined;
+  const detail = cause?.message ?? (error instanceof Error ? error.message : String(error));
+  return new GitFoxError(
+    `Cannot reach GitFox${hostOf(url)}: ${detail}${describeCause(cause)}.${proxyHint(error)}`,
+    { status: 502, code: 'unreachable' },
+  );
+}
+
+/**
+ * Decode a response body.
+ *
+ * @param {string} raw - raw response text.
+ * @param {boolean} keepRaw - whether a non-JSON body is returned as a string.
+ * @returns {any} parsed payload, raw text, or `undefined`.
+ */
+function decodePayload(raw, keepRaw) {
+  if (raw === '') return undefined;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return keepRaw ? raw : undefined;
+  }
+}
+
+/**
+ * Extract the most useful error message from a rejected response.
+ *
+ * @param {any} payload - decoded response payload.
+ * @param {string} raw - raw response text.
+ * @param {number} status - HTTP status code.
+ * @returns {string} human-readable message.
+ */
+function rejectionMessage(payload, raw, status) {
+  if (payload && typeof payload === 'object') {
+    if (typeof payload.message === 'string') return payload.message;
+    if (typeof payload.error === 'string') return payload.error;
+  }
+  return raw.slice(0, 300) || `GitFox answered HTTP ${status}.`;
+}
+
+/**
+ * @param {Response} response - failed response.
+ * @param {any} payload - decoded response payload.
+ * @param {string} raw - raw response text.
+ * @returns {GitFoxError} rejection error.
+ */
+function rejectionError(response, payload, raw) {
+  return new GitFoxError(rejectionMessage(payload, raw, response.status), {
+    status: response.status,
+    code: response.status === 401 ? 'unauthorized' : 'gitfox-rejected',
+  });
+}
+
+/**
+ * Create a GitFox API client bound to a live configuration resolver.
+ *
+ * @param {{ resolveConfig: () => Promise<{ baseUrl: string, token: string }>, fetchImpl?: typeof fetch }} options - wiring.
+ * @returns {object} client with one method per supported DevOps operation.
+ */
+export function createGitFoxClient({ resolveConfig, fetchImpl = fetch, directFetchImpl }) {
+  const direct = directFetchImpl ?? (fetchImpl === globalThis.fetch ? directFetch : undefined);
+  /**
+   * Execute one GitFox request.
+   *
+   * @param {string} path - API path beginning with `/api/v1/`.
+   * @param {{ method?: string, body?: unknown, signal?: AbortSignal, raw?: boolean }} [options] - request options.
+   * @returns {Promise<any>} parsed JSON body, or `undefined` for an empty response.
+   */
+  async function request(path, options = {}) {
+    const config = await resolveConfig();
+    if (config.token === '') {
+      throw notConnectedError();
+    }
+    const url = joinUrl(config.baseUrl, path);
+    let response;
+    try {
+      response = await fetchImpl(url, buildRequestOptions(config, options));
+    } catch (error) {
+      // A dead proxy must not take GitFox down with it: retry the same request
+      // once without the environment proxy, then report the original cause.
+      if (direct === undefined || !isProxyConnectionFailure(error)) throw mapFetchError(error, url);
+      try {
+        response = await direct(url, buildRequestOptions(config, options));
+      } catch {
+        throw mapFetchError(error, url);
+      }
+    }
+    const raw = await response.text();
+    const payload = decodePayload(raw, options.raw === true);
+    if (!response.ok) {
+      throw rejectionError(response, payload, raw);
+    }
+    return payload;
+  }
+
+  /**
+   * Execute one public request. `/api/v1/config` advertises clone prefixes and
+   * must answer before a token exists, so discovery cannot require one.
+   *
+   * @param {string} path - API path beginning with `/api/v1/`.
+   * @param {{ signal?: AbortSignal }} [options] - request options.
+   * @returns {Promise<any>} parsed JSON body.
+   */
+  async function publicRequest(path, options = {}) {
+    const config = await resolveConfig();
+    const url = joinUrl(config.baseUrl, path);
+    const init = {
+      method: 'GET',
+      headers: { accept: 'application/json' },
+      signal: buildSignal(options.signal),
+    };
+    let response;
+    try {
+      response = await fetchImpl(url, init);
+    } catch (error) {
+      if (direct === undefined || !isProxyConnectionFailure(error)) throw mapFetchError(error, url);
+      try {
+        response = await direct(url, init);
+      } catch {
+        throw mapFetchError(error, url);
+      }
+    }
+    const raw = await response.text();
+    const payload = decodePayload(raw, false);
+    if (!response.ok) {
+      throw rejectionError(response, payload, raw);
+    }
+    return payload;
+  }
+
+  return {
+    request,
+    /** @returns {Promise<object>} public GitFox server configuration. */
+    getConfig: () => publicRequest('/api/v1/config'),
+    /** @returns {Promise<unknown>} the authenticated GitFox user. */
+    me: () => request('/api/v1/auth/me'),
+    /**
+     * @param {{ page?: number, per_page?: number }} [query] - pagination.
+     * @returns {Promise<unknown[]>} visible projects.
+     */
+    listProjects: (query = {}) => request(withQuery('/api/v1/projects', query)),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {{ state?: string, page?: number, per_page?: number }} [query] - filters.
+     * @returns {Promise<unknown>} paginated issue list.
+     */
+    listIssues: (project, query = {}) =>
+      request(withQuery(`${projectPath(project)}/issues`, query)),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped issue id.
+     * @returns {Promise<unknown>} issue detail.
+     */
+    getIssue: (project, iid) => request(`${projectPath(project)}/issues/${encodeURIComponent(iid)}`),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {{ title: string, description?: string, labels?: string[] }} body - issue fields.
+     * @param {{ botName?: string }} [options] - attribution; a bot name writes `bot_name`.
+     * @returns {Promise<unknown>} created issue.
+     */
+    createIssue: (project, body, options = {}) =>
+      request(`${projectPath(project)}/issues`, {
+        method: 'POST',
+        body: withBotName(body, attribution(options)),
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped issue id.
+     * @param {object} body - mutable issue fields, including `state`.
+     * @returns {Promise<unknown>} updated issue.
+     */
+    updateIssue: (project, iid, body) =>
+      request(`${projectPath(project)}/issues/${encodeURIComponent(iid)}`, { method: 'PUT', body }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped issue id.
+     * @returns {Promise<unknown[]>} issue comments in creation order.
+     */
+    listIssueNotes: (project, iid) =>
+      request(`${projectPath(project)}/issues/${encodeURIComponent(iid)}/notes`),
+    /**
+     * GitFox stores issue comments with a `body` field; merge-request comments
+     * use `content`. Both are comments to the caller, so the client keeps one
+     * shape and maps it per resource.
+     *
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped issue id.
+     * @param {{ body: string }} note - comment text.
+     * @returns {Promise<unknown>} created note.
+     */
+    addIssueNote: (project, iid, note) =>
+      request(`${projectPath(project)}/issues/${encodeURIComponent(iid)}/notes`, {
+        method: 'POST',
+        body: { body: note.body },
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {{ status?: string, page?: number, per_page?: number }} [query] - filters.
+     * @returns {Promise<unknown[]>} merge requests.
+     */
+    listMergeRequests: (project, query = {}) =>
+      request(withQuery(`${projectPath(project)}/merge_requests`, query)),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {{ title: string, source_branch: string, target_branch: string, description?: string, is_draft?: boolean }} body - merge request fields.
+     * @param {{ botName?: string }} [options] - attribution; a bot name writes `bot_name`.
+     * @returns {Promise<unknown>} created merge request.
+     */
+    createMergeRequest: (project, body, options = {}) =>
+      request(`${projectPath(project)}/merge_requests`, {
+        method: 'POST',
+        body: withBotName(body, attribution(options)),
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped merge request id.
+     * @param {{ title?: string, description?: string, state?: 'open' | 'closed' }} body - fields to change.
+     * @returns {Promise<unknown>} updated merge request.
+     */
+    updateMergeRequest: (project, iid, body) =>
+      request(`${projectPath(project)}/merge_requests/${encodeURIComponent(iid)}`, {
+        method: 'PUT',
+        body,
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped merge request id.
+     * @param {{ squash?: boolean, delete_source_branch?: boolean }} [body] - merge options.
+     * @returns {Promise<unknown>} merge result.
+     */
+    mergeMergeRequest: (project, iid, body = {}) =>
+      request(`${projectPath(project)}/merge_requests/${encodeURIComponent(iid)}/merge`, {
+        method: 'PUT',
+        body,
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped merge request id.
+     * @returns {Promise<unknown[]>} merge-request comments in creation order.
+     */
+    listMergeRequestNotes: (project, iid) =>
+      request(`${projectPath(project)}/merge_requests/${encodeURIComponent(iid)}/notes`),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {number} iid - project-scoped merge request id.
+     * @param {{ body: string }} note - comment text.
+     * @returns {Promise<unknown>} created comment.
+     */
+    addMergeRequestNote: (project, iid, note) =>
+      request(`${projectPath(project)}/merge_requests/${encodeURIComponent(iid)}/notes`, {
+        method: 'POST',
+        body: { content: note.body },
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @returns {Promise<unknown[]>} branches with their head commit.
+     */
+    listBranches: (project) => request(`${projectPath(project)}/repository/branches`),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {{ name: string, ref: string }} body - new branch and source ref.
+     * @returns {Promise<unknown>} created branch.
+     */
+    createBranch: (project, body) =>
+      request(`${projectPath(project)}/repository/branches`, {
+        method: 'POST',
+        body: { name: body.name, ref_name: body.ref },
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {string} branch - branch name; slashes allowed.
+     * @returns {Promise<undefined>} no content.
+     */
+    deleteBranch: (project, branch) =>
+      request(`${projectPath(project)}/repository/branches/${encodeURIComponent(branch)}`, {
+        method: 'DELETE',
+      }),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {{ ref?: string, page?: number, per_page?: number }} [query] - revision and paging.
+     * @returns {Promise<unknown[]>} commits.
+     */
+    listCommits: (project, query = {}) =>
+      request(
+        withQuery(`${projectPath(project)}/repository/commits`, {
+          ref_name: query.ref,
+          page: query.page,
+          per_page: query.per_page,
+        }),
+      ),
+    /**
+     * @param {unknown} project - `namespace/name`.
+     * @param {string} sha - commit id.
+     * @returns {Promise<unknown>} commit detail.
+     */
+    getCommit: (project, sha) =>
+      request(`${projectPath(project)}/repository/commits/${encodeURIComponent(sha)}`),
+  };
+}

package/lib/project-discovery.js

@@ -0,0 +1,62 @@
+/**
+ * GitFox project discovery.
+ *
+ * GitFox publishes its clone URL prefixes at `GET /api/v1/config`. The
+ * workspace's `origin` remote therefore names the project: strip the advertised
+ * prefix and the trailing `.git`, and the remaining two path segments are the
+ * canonical `namespace/name` reference.
+ */
+
+const PROJECT_SEGMENT = /^[^\s/]+$/;
+
+/**
+ * Normalize one advertised clone prefix for comparison.
+ *
+ * @param {unknown} value - prefix from the GitFox config endpoint.
+ * @returns {string | undefined} prefix without trailing slashes.
+ */
+function clonePrefix(value) {
+  if (typeof value !== 'string') return undefined;
+  const prefix = value.trim().replace(/\/+$/, '');
+  return prefix === '' ? undefined : prefix;
+}
+
+/**
+ * Derive the GitFox project from one clone URL and the server config.
+ *
+ * @param {unknown} remoteUrl - `git remote get-url origin` output.
+ * @param {{ ssh_clone_url_prefix?: unknown, http_clone_url_prefix?: unknown }} config - GitFox server config.
+ * @returns {string | null} `namespace/name`, or null when this is not a GitFox remote.
+ */
+export function projectFromCloneUrl(remoteUrl, config) {
+  if (typeof remoteUrl !== 'string') return null;
+  const url = remoteUrl.trim();
+  if (url === '') return null;
+  const prefixes = [clonePrefix(config?.ssh_clone_url_prefix), clonePrefix(config?.http_clone_url_prefix)].filter(
+    (prefix) => prefix !== undefined,
+  );
+  const prefix = prefixes.find((entry) => url.startsWith(entry));
+  if (prefix === undefined) return null;
+  const rest = url
+    .slice(prefix.length)
+    .replace(/^\/+/, '')
+    .replace(/\/+$/, '')
+    .replace(/\.git$/i, '')
+    .replace(/\/+$/, '');
+  const parts = rest.split('/');
+  if (parts.length !== 2 || parts.some((part) => !PROJECT_SEGMENT.test(part) || part === '.' || part === '..')) {
+    return null;
+  }
+  return parts.join('/');
+}
+
+/**
+ * Explain why discovery produced no project.
+ *
+ * @param {string} reason - stable reason id.
+ * @param {string | null} remoteUrl - observed remote.
+ * @returns {{ project: null, remoteUrl: string | null, reason: string }} discovery result.
+ */
+export function undiscovered(reason, remoteUrl = null) {
+  return { project: null, remoteUrl, reason };
+}

package/locale/en.json

@@ -0,0 +1,7 @@
+{
+  "meta": {
+    "title": "Infinity DevOps",
+    "description": "GitFox issues, merge requests, commits and branches in one panel, with an infinity_devops agent tool for the Fabric AI team."
+  },
+  "translate": "Translate"
+}

package/locale/zh.json

@@ -0,0 +1,7 @@
+{
+  "meta": {
+    "title": "Infinity DevOps",
+    "description": "在 Harness 面板中管理 GitFox 的议题、合并请求、提交与分支，并为 Fabric AI Team 提供 infinity_devops 工具。"
+  },
+  "translate": "翻译"
+}