artifacty 0.1.0

package/src/lib/i18n.js

@@ -0,0 +1,175 @@
+export const DEFAULT_LOCALE = "en";
+export const SUPPORTED_LOCALES = ["en", "ko"];
+
+const TRANSLATIONS = {
+  en: {
+    "nav.new": "New",
+    "nav.import": "Import",
+    "nav.api": "API",
+    "nav.index": "Index",
+    "nav.cancel": "Cancel",
+    "nav.artifact": "Artifact",
+    "nav.edit": "Edit",
+    "nav.diff": "Diff",
+    "nav.raw": "Raw",
+    "language.english": "English",
+    "language.korean": "Korean",
+    "dashboard.count": "{count} artifacts",
+    "dashboard.empty": "No artifacts published yet.",
+    "filter.search": "Search",
+    "filter.tag": "Tag",
+    "filter.source": "Source",
+    "filter.archived": "Archived",
+    "filter.submit": "Filter",
+    "filter.clear": "Clear",
+    "form.newTitle": "New Artifact",
+    "form.editTitle": "Edit {title}",
+    "form.title": "Title",
+    "form.format": "Format",
+    "form.source": "Source",
+    "form.type": "Type",
+    "form.tags": "Tags",
+    "form.content": "Content",
+    "form.saveVersion": "Save Version",
+    "form.create": "Create",
+    "form.importTitle": "Import Artifact",
+    "form.agent": "Agent",
+    "form.auto": "Auto",
+    "form.fileName": "File Name",
+    "form.importContent": "Content or JSON Payload",
+    "form.importSubmit": "Import",
+    "artifact.schema": "schema v{version}",
+    "artifact.archived": "archived {date}",
+    "artifact.bytes": "{size} bytes",
+    "artifact.archive": "Archive",
+    "artifact.restore": "Restore",
+    "diff.title": "{title} Diff",
+    "diff.from": "From",
+    "diff.to": "To",
+    "diff.line": "Line",
+    "diff.compare": "Compare",
+    "editor.formatJson": "Format JSON",
+    "editor.validJson": "Valid JSON",
+    "editor.invalidJson": "Invalid JSON: {message}",
+    "editor.htmlPreview": "HTML preview",
+    "editor.markdownPreview": "Markdown preview",
+    "editor.plainText": "Plain text",
+    "editor.mode": "{format} editor"
+  },
+  ko: {
+    "nav.new": "새로 만들기",
+    "nav.import": "가져오기",
+    "nav.api": "API",
+    "nav.index": "목록",
+    "nav.cancel": "취소",
+    "nav.artifact": "아티팩트",
+    "nav.edit": "편집",
+    "nav.diff": "비교",
+    "nav.raw": "원본",
+    "language.english": "영어",
+    "language.korean": "한국어",
+    "dashboard.count": "아티팩트 {count}개",
+    "dashboard.empty": "아직 게시된 아티팩트가 없습니다.",
+    "filter.search": "검색",
+    "filter.tag": "태그",
+    "filter.source": "소스",
+    "filter.archived": "보관됨",
+    "filter.submit": "필터",
+    "filter.clear": "초기화",
+    "form.newTitle": "새 아티팩트",
+    "form.editTitle": "{title} 편집",
+    "form.title": "제목",
+    "form.format": "포맷",
+    "form.source": "소스",
+    "form.type": "유형",
+    "form.tags": "태그",
+    "form.content": "내용",
+    "form.saveVersion": "버전 저장",
+    "form.create": "생성",
+    "form.importTitle": "아티팩트 가져오기",
+    "form.agent": "에이전트",
+    "form.auto": "자동",
+    "form.fileName": "파일 이름",
+    "form.importContent": "내용 또는 JSON 페이로드",
+    "form.importSubmit": "가져오기",
+    "artifact.schema": "스키마 v{version}",
+    "artifact.archived": "보관됨 {date}",
+    "artifact.bytes": "{size} 바이트",
+    "artifact.archive": "보관",
+    "artifact.restore": "복원",
+    "diff.title": "{title} 비교",
+    "diff.from": "이전",
+    "diff.to": "이후",
+    "diff.line": "라인",
+    "diff.compare": "비교",
+    "editor.formatJson": "JSON 정리",
+    "editor.validJson": "유효한 JSON",
+    "editor.invalidJson": "유효하지 않은 JSON: {message}",
+    "editor.htmlPreview": "HTML 미리보기",
+    "editor.markdownPreview": "Markdown 미리보기",
+    "editor.plainText": "일반 텍스트",
+    "editor.mode": "{format} 편집기"
+  }
+};
+
+export function resolveLocale(value) {
+  const normalized = String(value || "").trim().toLowerCase();
+  if (SUPPORTED_LOCALES.includes(normalized)) {
+    return normalized;
+  }
+  return DEFAULT_LOCALE;
+}
+
+export function localeFromUrl(url) {
+  return resolveLocale(url.searchParams.get("lang") || process.env.ARTIFACTY_LOCALE);
+}
+
+export function localeFromBodyOrUrl(body = {}, url) {
+  return resolveLocale(body.lang || url.searchParams.get("lang") || process.env.ARTIFACTY_LOCALE);
+}
+
+export function createI18n(locale = DEFAULT_LOCALE) {
+  const resolved = resolveLocale(locale);
+  const messages = TRANSLATIONS[resolved] || TRANSLATIONS[DEFAULT_LOCALE];
+
+  return {
+    locale: resolved,
+    t(key, params = {}) {
+      const template = messages[key] || TRANSLATIONS[DEFAULT_LOCALE][key] || key;
+      return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (_, name) => String(params[name] ?? ""));
+    }
+  };
+}
+
+export function localizedHref(href, locale) {
+  const resolved = resolveLocale(locale);
+  if (resolved === DEFAULT_LOCALE) {
+    return stripLocale(href);
+  }
+  const url = new URL(href, "http://artifacty.local");
+  url.searchParams.set("lang", resolved);
+  return `${url.pathname}${url.search}${url.hash}`;
+}
+
+export function switchLocaleHref(currentPath, locale) {
+  return localizedHref(currentPath || "/", locale);
+}
+
+export function editorMessages(locale = DEFAULT_LOCALE) {
+  const { t } = createI18n(locale);
+  return {
+    formatJson: t("editor.formatJson"),
+    validJson: t("editor.validJson"),
+    invalidJson: t("editor.invalidJson", { message: "{message}" }),
+    htmlPreview: t("editor.htmlPreview"),
+    markdownPreview: t("editor.markdownPreview"),
+    plainText: t("editor.plainText"),
+    mode: t("editor.mode", { format: "{format}" })
+  };
+}
+
+function stripLocale(href) {
+  const url = new URL(href, "http://artifacty.local");
+  url.searchParams.delete("lang");
+  return `${url.pathname}${url.search}${url.hash}`;
+}

package/src/lib/installer.js

@@ -0,0 +1,187 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { existsSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+
+const SUPPORTED_AGENTS = new Set(["all", "claude", "codex", "gemini"]);
+
+export async function installAgent(agent, options = {}) {
+  const normalized = normalizeAgent(agent);
+  if (!SUPPORTED_AGENTS.has(normalized)) {
+    throw new Error(`Unsupported agent: ${agent}`);
+  }
+
+  if (normalized === "all") {
+    const results = [];
+    for (const target of ["claude", "codex", "gemini"]) {
+      results.push(await installAgent(target, options));
+    }
+    return {
+      agent: "all",
+      results
+    };
+  }
+
+  if (normalized === "claude") {
+    return installClaude(options);
+  }
+  if (normalized === "codex") {
+    return installCodex(options);
+  }
+  return installGemini(options);
+}
+
+export function createMcpServerConfig(options = {}) {
+  const serverRoot = path.resolve(options.packageDir || options.projectDir || process.cwd());
+  const serverPath = path.resolve(options.serverPath || path.join(serverRoot, "src", "mcp-server.js"));
+  const env = {};
+
+  if (options.url || process.env.ARTIFACTY_URL) {
+    env.ARTIFACTY_URL = options.url || process.env.ARTIFACTY_URL;
+  }
+
+  if (options.home || process.env.ARTIFACTY_HOME) {
+    env.ARTIFACTY_HOME = path.resolve(options.home || process.env.ARTIFACTY_HOME);
+  }
+
+  return {
+    command: "node",
+    args: [serverPath],
+    env
+  };
+}
+
+export async function installClaude(options = {}) {
+  const projectDir = path.resolve(options.projectDir || process.cwd());
+  const targetPath = path.resolve(options.configPath || path.join(projectDir, ".mcp.json"));
+  const existing = await readJsonFile(targetPath, {});
+  const next = {
+    ...existing,
+    mcpServers: {
+      ...(existing.mcpServers || {}),
+      artifacty: createMcpServerConfig(options)
+    }
+  };
+
+  return writeInstallFile({
+    agent: "claude",
+    path: targetPath,
+    dryRun: options.dryRun,
+    content: `${JSON.stringify(next, null, 2)}\n`
+  });
+}
+
+export async function installGemini(options = {}) {
+  const projectDir = path.resolve(options.projectDir || process.cwd());
+  const targetPath = path.resolve(options.configPath || path.join(projectDir, ".gemini", "settings.json"));
+  const existing = await readJsonFile(targetPath, {});
+  const next = {
+    ...existing,
+    mcpServers: {
+      ...(existing.mcpServers || {}),
+      artifacty: {
+        ...createMcpServerConfig(options),
+        timeout: options.timeout || 30000,
+        trust: Boolean(options.trust)
+      }
+    }
+  };
+
+  return writeInstallFile({
+    agent: "gemini",
+    path: targetPath,
+    dryRun: options.dryRun,
+    content: `${JSON.stringify(next, null, 2)}\n`
+  });
+}
+
+export async function installCodex(options = {}) {
+  const targetPath = path.resolve(options.configPath || path.join(homedir(), ".codex", "config.toml"));
+  const existing = await readTextFile(targetPath, "");
+  const block = codexTomlBlock(createMcpServerConfig(options));
+  const next = replaceTomlBlock(existing, "mcp_servers.artifacty", block);
+
+  return writeInstallFile({
+    agent: "codex",
+    path: targetPath,
+    dryRun: options.dryRun,
+    content: next
+  });
+}
+
+export function codexTomlBlock(config) {
+  const envPairs = Object.entries(config.env || {})
+    .map(([key, value]) => `${key} = ${quoteTomlString(value)}`)
+    .join(", ");
+
+  return [
+    "[mcp_servers.artifacty]",
+    `command = ${quoteTomlString(config.command)}`,
+    `args = [${config.args.map(quoteTomlString).join(", ")}]`,
+    "startup_timeout_sec = 5.0",
+    `env = { ${envPairs} }`,
+    ""
+  ].join("\n");
+}
+
+export function replaceTomlBlock(existing, dottedName, block) {
+  const trimmed = existing.trimEnd();
+  const pattern = new RegExp(`\\n?\\[${escapeRegExp(dottedName)}\\][\\s\\S]*?(?=\\n\\[[^\\]]+\\]|$)`);
+  if (pattern.test(trimmed)) {
+    return `${trimmed.replace(pattern, `\n${block.trimEnd()}`)}\n`;
+  }
+  return `${trimmed}${trimmed ? "\n\n" : ""}${block}`;
+}
+
+async function writeInstallFile({ agent, path: targetPath, dryRun, content }) {
+  const current = await readTextFile(targetPath, "");
+  const changed = current !== content;
+
+  if (!dryRun && changed) {
+    await mkdir(path.dirname(targetPath), { recursive: true });
+    await writeFile(targetPath, content, "utf8");
+  }
+
+  return {
+    agent,
+    path: targetPath,
+    changed,
+    dryRun: Boolean(dryRun),
+    content
+  };
+}
+
+async function readJsonFile(filePath, fallback) {
+  if (!existsSync(filePath)) {
+    return fallback;
+  }
+
+  const raw = await readTextFile(filePath, "");
+  if (!raw.trim()) {
+    return fallback;
+  }
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    throw new Error(`Failed to parse ${filePath}: ${error.message}`);
+  }
+}
+
+async function readTextFile(filePath, fallback) {
+  if (!existsSync(filePath)) {
+    return fallback;
+  }
+  return readFile(filePath, "utf8");
+}
+
+function normalizeAgent(agent) {
+  return String(agent || "").trim().toLowerCase();
+}
+
+function quoteTomlString(value) {
+  return JSON.stringify(String(value));
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}