code-workspace-zhuiyi 0.1.0-beta.1

package/src/core/tools.js

@@ -0,0 +1,34 @@
+const { WorkspaceError } = require("./errors");
+
+const SUPPORTED_TOOLS = Object.freeze(["claude", "codex"]);
+
+function normalizeTools(value, label = "tools") {
+  let tools;
+  if (Array.isArray(value)) tools = value;
+  else if (value === "none") tools = [];
+  else if (value === "all") tools = [...SUPPORTED_TOOLS];
+  else tools = String(value || "").split(",").map((entry) => entry.trim()).filter(Boolean);
+  const normalized = [...new Set(tools)];
+  const unsupported = normalized.filter((tool) => !SUPPORTED_TOOLS.includes(tool));
+  if (unsupported.length > 0) {
+    throw new WorkspaceError("CLI_INVALID_TOOLS", `Unsupported AI tool${unsupported.length === 1 ? "" : "s"}: ${unsupported.join(", ")}`, {
+      actual: unsupported,
+      supported: SUPPORTED_TOOLS,
+      source: label,
+    });
+  }
+  return normalized;
+}
+
+function resolveWorkspaceTools(options = {}) {
+  if (options.explicit !== undefined) {
+    return { tools: normalizeTools(options.explicit, "cli"), source: "cli" };
+  }
+  const persisted = options.state?.tools;
+  if (persisted !== undefined) {
+    return { tools: normalizeTools(persisted, "workspace-state"), source: "workspace-state" };
+  }
+  return { tools: normalizeTools(options.manifestTools || SUPPORTED_TOOLS, "manifest"), source: "manifest" };
+}
+
+module.exports = { SUPPORTED_TOOLS, normalizeTools, resolveWorkspaceTools };

package/src/core/transaction.js

@@ -0,0 +1,132 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { atomicWrite } = require("./fs");
+
+const RETAINED_EFFECT_STATUSES = new Set(["applied", "possibly-applied"]);
+
+function normalizeRetainedEffect(effect) {
+  if (!effect || typeof effect !== "object" || !effect.kind) {
+    throw new Error("Retained effects require a kind");
+  }
+  const status = effect.status || (effect.verified === true ? "applied" : "possibly-applied");
+  if (!RETAINED_EFFECT_STATUSES.has(status)) {
+    throw new Error(`Invalid retained effect status: ${status}`);
+  }
+  return { ...effect, status };
+}
+
+function attachRetainedEffects(error, effects) {
+  const target = error instanceof Error ? error : new Error(String(error));
+  const additions = (effects || []).filter(Boolean).map(normalizeRetainedEffect);
+  if (additions.length === 0) return target;
+  const previousEffects = target.details?.effects || {};
+  target.details = {
+    ...(target.details || {}),
+    effects: {
+      ...previousEffects,
+      retained: [
+        ...(previousEffects.retained || []).map(normalizeRetainedEffect),
+        ...additions,
+      ],
+    },
+  };
+  return target;
+}
+
+function uniqueFiles(files) {
+  return [...new Set(files.map((file) => path.resolve(file)))];
+}
+
+function missingParents(file) {
+  const missing = [];
+  let directory = path.dirname(file);
+  while (!fs.existsSync(directory)) {
+    missing.push(directory);
+    const parent = path.dirname(directory);
+    if (parent === directory) break;
+    directory = parent;
+  }
+  return missing;
+}
+
+function createFileTransaction(files) {
+  const snapshots = uniqueFiles(files).map((file) => ({
+    file,
+    existed: fs.existsSync(file),
+    content: fs.existsSync(file) ? fs.readFileSync(file) : null,
+    missingParents: missingParents(file),
+  }));
+  const externalEffects = [];
+  let finished = false;
+
+  return {
+    recordExternalEffect(effect) {
+      if (effect?.verified !== true) {
+        throw new Error(`Cannot record an unverified external effect: ${effect?.kind || "unknown"}`);
+      }
+      externalEffects.push(normalizeRetainedEffect({ ...effect, status: "applied" }));
+    },
+    commit() {
+      finished = true;
+    },
+    rollback(error) {
+      if (finished) return;
+      const rollbackErrors = [];
+      const restored = [];
+      const removed = [];
+      for (const snapshot of snapshots.slice().reverse()) {
+        try {
+          if (snapshot.existed) {
+            atomicWrite(snapshot.file, snapshot.content);
+            restored.push(snapshot.file);
+          } else if (fs.existsSync(snapshot.file)) {
+            fs.unlinkSync(snapshot.file);
+            removed.push(snapshot.file);
+          }
+        } catch (rollbackError) {
+          rollbackErrors.push(`${snapshot.file}: ${rollbackError.message}`);
+        }
+      }
+      const directories = snapshots.flatMap((snapshot) => snapshot.missingParents).sort((left, right) => right.length - left.length);
+      for (const directory of [...new Set(directories)]) {
+        try {
+          if (fs.existsSync(directory) && fs.readdirSync(directory).length === 0) fs.rmdirSync(directory);
+        } catch (rollbackError) {
+          rollbackErrors.push(`${directory}: ${rollbackError.message}`);
+        }
+      }
+      finished = true;
+      if (error) {
+        const previousEffects = error.details?.effects || {};
+        const retained = [
+          ...(previousEffects.retained || []).map(normalizeRetainedEffect),
+          ...externalEffects.map((effect) => ({ ...effect, retained: true })),
+        ];
+        error.details = {
+          ...(error.details || {}),
+          workspaceRolledBack: rollbackErrors.length === 0,
+          ...(externalEffects.length > 0 ? { externalEffects } : {}),
+          ...(rollbackErrors.length > 0 ? { rollbackErrors } : {}),
+          effects: {
+            restored: [...new Set([...(previousEffects.restored || []), ...restored])],
+            removed: [...new Set([...(previousEffects.removed || []), ...removed])],
+            retained,
+            rollbackFailures: [...(previousEffects.rollbackFailures || []), ...rollbackErrors],
+          },
+        };
+      }
+    },
+    get externalEffects() {
+      return externalEffects.map((effect) => ({ ...effect }));
+    },
+  };
+}
+
+module.exports = {
+  attachRetainedEffects,
+  createFileTransaction,
+  missingParents,
+  normalizeRetainedEffect,
+  uniqueFiles,
+};

package/src/core/validation.js

@@ -0,0 +1,186 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const { add, result } = require("./diagnostics");
+const { CURRENT_CONFIG_VERSION } = require("./config");
+const { inspectGitWorktree } = require("./project");
+
+function isSameOrDescendant(parent, candidate) {
+  const relative = path.relative(parent, candidate);
+  return relative === "" || (!relative.startsWith(`..${path.sep}`) && relative !== ".." && !path.isAbsolute(relative));
+}
+
+function diagnosticProjects(...values) {
+  return [...new Set(values.flat().filter((value) => typeof value === "string" && value))];
+}
+
+function addExistingDiagnostic(output, diagnostic) {
+  output.diagnostics.push(diagnostic);
+  if (diagnostic.severity === "error") output.errors.push(diagnostic.message);
+  if (diagnostic.severity === "warning") output.warnings.push(diagnostic.message);
+}
+
+function validateSchemaAndRegistry(output, config) {
+  if (![1, CURRENT_CONFIG_VERSION].includes(config.schemaVersion)) {
+    add(output, "error", "UNSUPPORTED_SCHEMA_VERSION", `Unsupported schemaVersion: ${config.schemaVersion}`);
+  }
+  if (!Array.isArray(config.projects)) {
+    add(output, "error", "PROJECTS_NOT_ARRAY", "projects must be an array.");
+    return false;
+  }
+  return true;
+}
+
+function validateProjectFields(output, project, label) {
+  if (!project || typeof project !== "object" || Array.isArray(project)) {
+    add(output, "error", "PROJECT_NOT_OBJECT", `Project ${label} must be a mapping.`);
+    return false;
+  }
+  for (const field of ["name", "location", "branch", "type", "context"]) {
+    if (typeof project[field] !== "string" || !project[field].trim()) {
+      add(output, "error", "PROJECT_FIELD_REQUIRED", `Project ${label} must contain a non-empty ${field}.`, { projectName: project.name || null, field });
+    }
+  }
+  if (project.updateLatest !== undefined && typeof project.updateLatest !== "boolean") {
+    add(output, "error", "PROJECT_UPDATE_LATEST_INVALID", `Project ${label} updateLatest must be a boolean when present.`, {
+      projectName: project.name || null,
+      field: "updateLatest",
+      actual: project.updateLatest,
+    });
+  }
+  if (typeof project.location !== "string" || !path.isAbsolute(project.location)) {
+    add(output, "error", "PROJECT_LOCATION_NOT_ABSOLUTE", `Project ${label} location must be absolute: ${project.location}`, { projectName: project.name || null });
+    return false;
+  }
+  return true;
+}
+
+function inspectValidatedProject(output, rootRealPath, project, label, inspect) {
+  try {
+    const actual = inspect(project.location);
+    if (isSameOrDescendant(actual.realPath, rootRealPath) || isSameOrDescendant(rootRealPath, actual.realPath)) {
+      add(output, "error", "PROJECT_OVERLAPS_WORKSPACE", `Project ${label} must not overlap the workspace root: ${actual.realPath}`, { projectName: project.name || null });
+    }
+    if (project.branch && project.branch !== actual.branch) {
+      add(output, "error", "PROJECT_BRANCH_MISMATCH", `Project ${label} registered branch ${project.branch} does not match actual branch ${actual.branch}.`, {
+        projectName: project.name || null,
+        registeredBranch: project.branch,
+        actualBranch: actual.branch,
+        location: actual.realPath,
+      });
+    }
+    return actual;
+  } catch (error) {
+    add(output, "error", "PROJECT_INSPECTION_FAILED", `Project ${label} cannot be inspected: ${error.message}`, {
+      projectName: project.name || null,
+      location: project.location,
+      cause: error.code || error.name,
+    });
+    return null;
+  }
+}
+
+function validateProjects(root, config) {
+  const output = result();
+  if (!validateSchemaAndRegistry(output, config)) return output;
+  if (config.projects.length === 0) {
+    add(output, "warning", "NO_PROJECTS", "No local projects are configured.");
+    return output;
+  }
+
+  const rootRealPath = fs.realpathSync(root);
+  const names = new Map();
+  const inspected = [];
+
+  config.projects.forEach((project, index) => {
+    const label = project?.name || `#${index + 1}`;
+    if (!validateProjectFields(output, project, label)) return;
+    if (project.name) {
+      const previous = names.get(project.name);
+      if (previous) add(output, "error", "DUPLICATE_PROJECT_NAME", `Duplicate project name: ${project.name}`, {
+        projectName: project.name,
+        projects: diagnosticProjects(previous, project.name),
+      });
+      else names.set(project.name, project.name);
+    }
+    const actual = inspectValidatedProject(output, rootRealPath, project, label, inspectGitWorktree);
+    if (actual) {
+      inspected.push({ name: label, projectName: project.name || null, realPath: actual.realPath });
+    }
+  });
+
+  for (let left = 0; left < inspected.length; left += 1) {
+    for (let right = left + 1; right < inspected.length; right += 1) {
+      const a = inspected[left];
+      const b = inspected[right];
+      if (a.realPath === b.realPath) {
+        add(output, "error", "DUPLICATE_PROJECT_PATH", `Projects ${a.name} and ${b.name} resolve to the same directory: ${a.realPath}`, {
+          projects: diagnosticProjects(a.projectName, b.projectName),
+        });
+      } else if (isSameOrDescendant(a.realPath, b.realPath) || isSameOrDescendant(b.realPath, a.realPath)) {
+        add(output, "error", "NESTED_PROJECT_PATH", `Projects ${a.name} and ${b.name} must not be nested.`, {
+          projects: diagnosticProjects(a.projectName, b.projectName),
+        });
+      }
+    }
+  }
+  return output;
+}
+
+function validateProject(root, config, name, options = {}) {
+  const output = result();
+  if (!validateSchemaAndRegistry(output, config)) return output;
+  const matches = config.projects
+    .map((project, index) => ({ project, index }))
+    .filter(({ project }) => project && typeof project === "object" && !Array.isArray(project) && project.name === name);
+  if (matches.length === 0) {
+    add(output, "error", "PROJECT_NOT_FOUND", `Unknown local project: ${name}`, { projectName: name });
+    return output;
+  }
+  const { project, index } = matches[0];
+  const label = project.name || `#${index + 1}`;
+  if (!validateProjectFields(output, project, label)) return output;
+  if (matches.length > 1) {
+    add(output, "error", "DUPLICATE_PROJECT_NAME", `Duplicate project name: ${name}`, {
+      projectName: name,
+      projects: [name],
+    });
+  }
+
+  const rootRealPath = fs.realpathSync(root);
+  inspectValidatedProject(output, rootRealPath, project, label, options.inspectGitWorktree || inspectGitWorktree);
+  const targetPath = path.resolve(project.location);
+  config.projects.forEach((other, otherIndex) => {
+    if (otherIndex === index || !other || typeof other !== "object" || Array.isArray(other)) return;
+    if (typeof other.location !== "string" || !path.isAbsolute(other.location)) return;
+    const otherPath = path.resolve(other.location);
+    if (targetPath === otherPath) {
+      add(output, "error", "DUPLICATE_PROJECT_PATH", `Projects ${label} and ${other.name || `#${otherIndex + 1}`} use the same registered directory: ${targetPath}`, {
+        projectName: name,
+        projects: diagnosticProjects(name, other.name),
+      });
+    } else if (isSameOrDescendant(targetPath, otherPath) || isSameOrDescendant(otherPath, targetPath)) {
+      add(output, "error", "NESTED_PROJECT_PATH", `Projects ${label} and ${other.name || `#${otherIndex + 1}`} must not be nested.`, {
+        projectName: name,
+        projects: diagnosticProjects(name, other.name),
+      });
+    }
+  });
+  return output;
+}
+
+function validateProjectSelection(root, config, names, options = {}) {
+  const output = result();
+  for (const name of names) {
+    const selected = validateProject(root, config, name, options);
+    for (const diagnostic of selected.diagnostics) addExistingDiagnostic(output, diagnostic);
+  }
+  return output;
+}
+
+module.exports = {
+  isSameOrDescendant,
+  validateProject,
+  validateProjectSelection,
+  validateProjects,
+};

package/src/i18n/index.js

@@ -0,0 +1,11 @@
+const { interpolate } = require("./interpolate");
+const { DEFAULT_LANGUAGE_CODE, LANGUAGE_CODES, LANGUAGE_OPTIONS, LOCALES, getLocale } = require("./registry");
+
+module.exports = {
+  DEFAULT_LANGUAGE_CODE,
+  LANGUAGE_CODES,
+  LANGUAGE_OPTIONS,
+  LOCALES,
+  getLocale,
+  interpolate,
+};

package/src/i18n/interpolate.js

@@ -0,0 +1,7 @@
+function interpolate(template, values = {}) {
+  return String(template).replace(/\{([A-Za-z][A-Za-z0-9]*)\}/g, (match, key) => (
+    Object.hasOwn(values, key) ? String(values[key]) : match
+  ));
+}
+
+module.exports = { interpolate };

package/src/i18n/locales/en-US.js

@@ -0,0 +1,10 @@
+module.exports = {
+  code: "en-US",
+  label: "English",
+  projectContext: {
+    responsibility: "Responsibility",
+    technologyStack: "Technology stack",
+    codeLocations: "Code locations",
+    projectBoundary: "Project boundary",
+  },
+};

package/src/i18n/locales/zh-CN.js

@@ -0,0 +1,11 @@
+module.exports = {
+  code: "zh-CN",
+  label: "中文（简体）",
+  default: true,
+  projectContext: {
+    responsibility: "职责",
+    technologyStack: "技术栈",
+    codeLocations: "代码定位",
+    projectBoundary: "项目边界",
+  },
+};

package/src/i18n/registry.js

@@ -0,0 +1,42 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const LOCALES_DIRECTORY = path.join(__dirname, "locales");
+const LOCALES = Object.freeze(
+  fs.readdirSync(LOCALES_DIRECTORY)
+    .filter((file) => file.endsWith(".js"))
+    .sort()
+    .map((file) => require(path.join(LOCALES_DIRECTORY, file)))
+    .sort((left, right) => left.code.localeCompare(right.code))
+);
+const LOCALES_BY_CODE = new Map(LOCALES.map((locale) => [locale.code, locale]));
+const LANGUAGE_CODES = Object.freeze(LOCALES.map((locale) => locale.code));
+const LANGUAGE_OPTIONS = Object.freeze(LOCALES.map((locale) => Object.freeze({
+  value: locale.code,
+  label: locale.label,
+})));
+
+if (LOCALES_BY_CODE.size !== LOCALES.length) throw new Error("Duplicate locale code in i18n registry");
+if (LOCALES.length === 0) throw new Error("At least one locale must be registered");
+for (const locale of LOCALES) {
+  if (!locale?.code || !/^[A-Za-z0-9-]+$/.test(locale.code) || !locale.label || !locale.projectContext) {
+    throw new Error(`Invalid locale definition: ${locale?.code || "<missing>"}`);
+  }
+}
+const defaults = LOCALES.filter((locale) => locale.default === true);
+if (defaults.length !== 1) throw new Error("Exactly one locale must be the default");
+const DEFAULT_LANGUAGE_CODE = defaults[0].code;
+
+function getLocale(code) {
+  const locale = LOCALES_BY_CODE.get(String(code || "").trim());
+  if (!locale) throw new Error(`Unsupported locale: ${code || "<missing>"}`);
+  return locale;
+}
+
+module.exports = {
+  DEFAULT_LANGUAGE_CODE,
+  LANGUAGE_CODES,
+  LANGUAGE_OPTIONS,
+  LOCALES,
+  getLocale,
+};

package/src/index.js

@@ -0,0 +1,25 @@
+const config = require("./core/config");
+const doctor = require("./core/doctor");
+const init = require("./core/init");
+const initializer = require("./core/initializer");
+const i18n = require("./i18n");
+const language = require("./core/language");
+const managedFiles = require("./core/managed-files");
+const monitor = require("./monitor");
+const monitorPage = require("./monitor/page");
+const project = require("./core/project");
+const validation = require("./core/validation");
+
+module.exports = {
+  ...config,
+  ...doctor,
+  ...init,
+  ...initializer,
+  ...i18n,
+  ...language,
+  ...managedFiles,
+  ...monitor,
+  ...monitorPage,
+  ...project,
+  ...validation,
+};

package/src/init/plan.js

@@ -0,0 +1,12 @@
+function createInitPlan({ root, workspace, tools, monitor, language, extensions = [] }) {
+  return {
+    root,
+    workspace,
+    tools: tools.slice(),
+    monitor: { ...monitor },
+    language,
+    extensions: extensions.slice(),
+  };
+}
+
+module.exports = { createInitPlan };

package/src/init/ui.js

@@ -0,0 +1,61 @@
+async function createInteractiveUi(options = {}) {
+  const clack = await import("@clack/prompts");
+  const input = options.input || process.stdin;
+  const output = options.output || process.stdout;
+  const common = { input, output };
+  const cancelMessage = options.cancelMessage || "Initialization cancelled. No changes were made.";
+  const cancelCode = options.cancelCode || "INIT_CANCELLED";
+
+  function unwrap(value) {
+    if (!clack.isCancel(value)) return value;
+    clack.cancel(cancelMessage, common);
+    const error = new Error(cancelMessage);
+    error.code = cancelCode;
+    throw error;
+  }
+
+  return {
+    intro(message = "Code Workspace setup") {
+      clack.intro(message, common);
+    },
+    note(title, lines) {
+      clack.note(lines.join("\n"), title, common);
+    },
+    async text(label, initial) {
+      return unwrap(await clack.text({
+        ...common,
+        message: label,
+        placeholder: initial,
+        defaultValue: initial,
+      }));
+    },
+    async select(label, choices, initial = 0) {
+      return unwrap(await clack.select({
+        ...common,
+        message: label,
+        options: choices,
+        initialValue: choices[initial]?.value,
+      }));
+    },
+    async multiselect(label, choices, initialValues = []) {
+      return unwrap(await clack.multiselect({
+        ...common,
+        message: label,
+        options: choices,
+        initialValues,
+        required: false,
+      }));
+    },
+    async confirm(label, initial = true) {
+      return unwrap(await clack.confirm({ ...common, message: label, initialValue: initial }));
+    },
+    cancel(message) {
+      clack.cancel(message, common);
+    },
+    close(message) {
+      clack.outro(message, common);
+    },
+  };
+}
+
+module.exports = { createInteractiveUi };

package/src/init/wizard.js

@@ -0,0 +1,97 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { randomUUID } = require("node:crypto");
+
+const { DEFAULT_MONITOR_URL, DEFAULT_WORKSPACE_NAME, configPath, loadConfig } = require("../core/config");
+const { DEFAULT_WORKSPACE_LANGUAGE, SUPPORTED_LANGUAGES, resolveWorkspaceLanguage } = require("../core/language");
+const { createInitPlan } = require("./plan");
+const { createInteractiveUi } = require("./ui");
+const { formatPermissionPlan, planPermissionChanges } = require("../core/permissions");
+const { resolveExtensionPlans } = require("../core/extensions");
+
+async function collectInitPlan(root, manifest, options = {}) {
+  const ui = options.ui || await createInteractiveUi(options);
+  ui.intro();
+  ui.note("Environment", [
+    `Node.js ${options.nodeVersion || process.versions.node}`,
+    `Target ${root}`,
+  ]);
+
+  const requestedLanguage = options.language;
+  const existingLanguage = resolveWorkspaceLanguage(root, {
+    language: requestedLanguage,
+    defaultLanguage: DEFAULT_WORKSPACE_LANGUAGE,
+    allowLegacy: true,
+  });
+  const existing = fs.existsSync(configPath(root)) ? loadConfig(root, { defaultLanguage: existingLanguage }) : null;
+  const name = existing?.workspace?.name || options.workspaceName || await ui.text("Workspace name", DEFAULT_WORKSPACE_NAME);
+  const languageChoices = SUPPORTED_LANGUAGES.map((entry) => ({
+    value: entry.value,
+    label: `${entry.label} · ${entry.value}`,
+  }));
+  const language = requestedLanguage || await ui.select(
+    "Workspace language",
+    languageChoices,
+    Math.max(0, languageChoices.findIndex((entry) => entry.value === existingLanguage))
+  );
+  const toolChoices = [
+    { value: "claude", label: "Claude Code" },
+    { value: "codex", label: "Codex" },
+  ];
+  const tools = options.tools || await ui.multiselect(
+    "Agent tools (select any)",
+    toolChoices,
+    options.initialTools || ["claude", "codex"]
+  );
+  const extensionCatalog = options.extensionCatalog || [];
+  const supportedExtensions = extensionCatalog.filter((entry) => entry.latestSupported);
+  const extensionNames = options.extensions !== undefined
+    ? options.extensions
+    : supportedExtensions.length > 0
+      ? await ui.multiselect(
+        "Extensions (experimental, select any)",
+        supportedExtensions.map((entry) => ({
+          value: entry.id,
+          label: `${entry.name} · latest supported: ${entry.latestSupported.version} · Extension Spec ${entry.latestSupported.extensionSpecVersion}`,
+        })),
+        options.initialExtensions || []
+      )
+      : [];
+  const extensions = resolveExtensionPlans(extensionCatalog, extensionNames, {
+    tools,
+    state: options.extensionState,
+  });
+  let monitorEnabled = options.monitor !== undefined ? options.monitor : existing?.monitor?.enable;
+  if (tools.includes("codex") && monitorEnabled === undefined) monitorEnabled = await ui.confirm("Enable Codex Agent monitor?", true);
+  const monitor = {
+    enable: tools.includes("codex") && monitorEnabled === true,
+    url: options.monitorUrl || existing?.monitor?.url || DEFAULT_MONITOR_URL,
+  };
+  const workspace = existing?.workspace || { name, uuid: randomUUID() };
+  const plan = createInitPlan({ root, workspace, tools, monitor, language, extensions });
+  ui.note("Ready to initialize", [
+    `Workspace  ${workspace.name}`,
+    `Language   ${language}`,
+    `Tools      ${tools.length ? tools.join(", ") : "none"}`,
+    `Monitor    ${monitor.enable ? monitor.url : "disabled"}`,
+    `Extensions ${extensions.length ? extensions.map((entry) => `${entry.id}@${entry.version} [Spec ${entry.extensionSpecVersion}] (${entry.manifestSha256})`).join(", ") : "none"}`,
+  ]);
+  if (existing?.projects?.length) {
+    const permissionPlan = planPermissionChanges({
+      root,
+      tools,
+      grants: existing.projects.map((project) => project.location),
+    });
+    ui.note("Agent authorization", formatPermissionPlan(permissionPlan).split("\n"));
+  }
+  if (!await ui.confirm("Continue?", true)) {
+    (ui.cancel || ui.close)("Initialization cancelled. No changes were made.");
+    const error = new Error("Initialization cancelled. No changes were made.");
+    error.code = "INIT_CANCELLED";
+    throw error;
+  }
+  ui.close("Plan confirmed. Starting initialization…");
+  return plan;
+}
+
+module.exports = { collectInitPlan };

package/src/monitor/i18n/index.js

@@ -0,0 +1,33 @@
+const fs = require("node:fs");
+const path = require("node:path");
+
+const LOCALES_DIRECTORY = path.join(__dirname, "locales");
+const MONITOR_LOCALES = Object.freeze(
+  fs.readdirSync(LOCALES_DIRECTORY)
+    .filter((file) => file.endsWith(".js"))
+    .sort()
+    .map((file) => require(path.join(LOCALES_DIRECTORY, file)))
+    .sort((left, right) => left.code.localeCompare(right.code))
+);
+const LOCALES_BY_CODE = new Map(MONITOR_LOCALES.map((locale) => [locale.code, locale]));
+
+if (MONITOR_LOCALES.length === 0) throw new Error("At least one monitor locale must be registered");
+if (LOCALES_BY_CODE.size !== MONITOR_LOCALES.length) throw new Error("Duplicate monitor locale code");
+for (const locale of MONITOR_LOCALES) {
+  if (!locale?.code || !locale.label || !locale.messages) throw new Error(`Invalid monitor locale: ${locale?.code || "<missing>"}`);
+}
+const defaults = MONITOR_LOCALES.filter((locale) => locale.default === true);
+if (defaults.length !== 1) throw new Error("Exactly one monitor locale must be the default");
+
+const DEFAULT_MONITOR_LANGUAGE = defaults[0].code;
+const MONITOR_MESSAGES = Object.freeze(Object.fromEntries(
+  MONITOR_LOCALES.map((locale) => [locale.code, locale.messages])
+));
+
+function getMonitorLocale(code) {
+  const locale = LOCALES_BY_CODE.get(String(code || "").trim());
+  if (!locale) throw new Error(`Unsupported monitor locale: ${code || "<missing>"}`);
+  return locale;
+}
+
+module.exports = { DEFAULT_MONITOR_LANGUAGE, MONITOR_LOCALES, MONITOR_MESSAGES, getMonitorLocale };