muonroi-cli 1.2.0

package/src/utils/install-manager.ts

@@ -0,0 +1,429 @@
+import { spawn } from "child_process";
+import { createHash } from "crypto";
+import fs from "fs";
+import os from "os";
+import path from "path";
+import readline from "readline";
+import semverGt from "semver/functions/gt.js";
+import semverValid from "semver/functions/valid.js";
+
+export const GITHUB_REPO = "muonroi/muonroi-cli";
+export const RELEASES_API = `https://api.github.com/repos/${GITHUB_REPO}/releases`;
+export const SCRIPT_INSTALL_METHOD = "script";
+
+const FETCH_TIMEOUT_MS = 5_000;
+const INSTALL_SCHEMA_VERSION = 1;
+const PATH_MARKER = "# muonroi-cli";
+const CONFIG_FILENAMES = ["user-settings.json", "AGENTS.md"];
+const DATA_ENTRIES = ["daemon.pid", "delegations", "muonroi.db", "models", "schedules"];
+
+export interface ReleaseTarget {
+  key: "darwin-arm64" | "linux-x64" | "windows-x64";
+  assetName: string;
+  binaryName: string;
+}
+
+export interface ScriptInstallMetadata {
+  schemaVersion: number;
+  installMethod: typeof SCRIPT_INSTALL_METHOD;
+  version: string;
+  repo: string;
+  binaryPath: string;
+  installDir: string;
+  assetName: string;
+  target: ReleaseTarget["key"];
+  installedAt: string;
+  shellConfigPath?: string;
+  pathCommand?: string;
+}
+
+export interface ScriptInstallContext {
+  metadata: ScriptInstallMetadata;
+  target: ReleaseTarget;
+  binaryPath: string;
+}
+
+export interface ScriptUpdateRunResult {
+  success: boolean;
+  output: string;
+}
+
+export interface ScriptUninstallOptions {
+  dryRun?: boolean;
+  force?: boolean;
+  keepConfig?: boolean;
+  keepData?: boolean;
+}
+
+export interface ScriptUninstallPlan {
+  removePaths: string[];
+  pruneDirs: string[];
+  pathCleanup?: { configFile: string; command: string };
+}
+
+interface GitHubReleaseAsset {
+  name: string;
+  browser_download_url: string;
+}
+
+interface GitHubRelease {
+  tag_name: string;
+  assets: GitHubReleaseAsset[];
+}
+
+interface ReleaseDownload {
+  version: string;
+  asset: GitHubReleaseAsset;
+  checksums: GitHubReleaseAsset;
+}
+
+export function getUserDir(homeDir = os.homedir()): string {
+  return path.join(homeDir, ".muonroi-cli");
+}
+
+export function getScriptInstallDir(homeDir = os.homedir()): string {
+  return path.join(getUserDir(homeDir), "bin");
+}
+
+export function getInstallMetadataPath(homeDir = os.homedir()): string {
+  return path.join(getUserDir(homeDir), "install.json");
+}
+
+export function getReleaseTargetForPlatform(platform = process.platform, arch = process.arch): ReleaseTarget | null {
+  if (platform === "darwin" && (arch === "arm64" || arch === "x64"))
+    return { key: "darwin-arm64", assetName: "muonroi-cli-darwin-arm64", binaryName: "muonroi-cli" };
+  if (platform === "linux" && arch === "x64")
+    return { key: "linux-x64", assetName: "muonroi-cli-linux-x64", binaryName: "muonroi-cli" };
+  if (platform === "win32" && arch === "x64")
+    return { key: "windows-x64", assetName: "muonroi-cli-windows-x64.exe", binaryName: "muonroi-cli.exe" };
+  return null;
+}
+
+export function loadScriptInstallMetadata(homeDir = os.homedir()): ScriptInstallMetadata | null {
+  const metadataPath = getInstallMetadataPath(homeDir);
+  try {
+    if (!fs.existsSync(metadataPath)) return null;
+    const parsed = JSON.parse(fs.readFileSync(metadataPath, "utf8")) as Partial<ScriptInstallMetadata>;
+    if (parsed.installMethod !== SCRIPT_INSTALL_METHOD) return null;
+    if (
+      typeof parsed.binaryPath !== "string" ||
+      typeof parsed.installDir !== "string" ||
+      typeof parsed.assetName !== "string" ||
+      typeof parsed.target !== "string"
+    )
+      return null;
+    return {
+      schemaVersion: INSTALL_SCHEMA_VERSION,
+      installMethod: SCRIPT_INSTALL_METHOD,
+      version: typeof parsed.version === "string" ? parsed.version : "unknown",
+      repo: typeof parsed.repo === "string" ? parsed.repo : GITHUB_REPO,
+      binaryPath: parsed.binaryPath,
+      installDir: parsed.installDir,
+      assetName: parsed.assetName,
+      target: parsed.target as ReleaseTarget["key"],
+      installedAt: typeof parsed.installedAt === "string" ? parsed.installedAt : new Date(0).toISOString(),
+      shellConfigPath: typeof parsed.shellConfigPath === "string" ? parsed.shellConfigPath : undefined,
+      pathCommand: typeof parsed.pathCommand === "string" ? parsed.pathCommand : undefined,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function saveScriptInstallMetadata(metadata: ScriptInstallMetadata, homeDir = os.homedir()): void {
+  const metadataPath = getInstallMetadataPath(homeDir);
+  fs.mkdirSync(path.dirname(metadataPath), { recursive: true, mode: 0o700 });
+  fs.writeFileSync(metadataPath, `${JSON.stringify(metadata, null, 2)}\n`, { mode: 0o600 });
+}
+
+export function getScriptInstallContext(homeDir = os.homedir()): ScriptInstallContext | null {
+  const target = getReleaseTargetForPlatform();
+  if (!target) return null;
+
+  const metadata = loadScriptInstallMetadata(homeDir);
+  if (metadata) {
+    return {
+      metadata,
+      target: getReleaseTargetForPlatformKey(metadata.target) ?? target,
+      binaryPath: metadata.binaryPath,
+    };
+  }
+
+  return null;
+}
+
+export async function fetchLatestReleaseVersion(): Promise<string | null> {
+  const release = await fetchReleaseJson(`${RELEASES_API}/latest`);
+  return release ? normalizeReleaseVersion(release.tag_name) : null;
+}
+
+export function parseChecksumsFile(contents: string): Map<string, string> {
+  const result = new Map<string, string>();
+  for (const rawLine of contents.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line) continue;
+    const match = line.match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
+    if (!match) continue;
+    result.set(match[2], match[1].toLowerCase());
+  }
+  return result;
+}
+
+export async function runScriptManagedUpdate(currentVersion: string): Promise<ScriptUpdateRunResult> {
+  const context = getScriptInstallContext();
+  if (!context) return notScriptManaged("update");
+
+  const normalizedCurrent = semverValid(currentVersion);
+  if (!normalizedCurrent) {
+    return { success: false, output: `Cannot update: current version "${currentVersion}" is invalid.` };
+  }
+
+  const release = await resolveReleaseDownload(context.target);
+  if (!release) {
+    return { success: false, output: "No matching release found for this platform." };
+  }
+
+  if (!semverGt(release.version, normalizedCurrent)) {
+    return { success: true, output: `Already on the latest version (${normalizedCurrent}).` };
+  }
+
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "muonroi-cli-update-"));
+  try {
+    const downloadedPath = path.join(tempDir, release.asset.name);
+    await downloadBinary(release.asset.browser_download_url, downloadedPath);
+
+    const checksumsText = await downloadText(release.checksums.browser_download_url);
+    const expectedHash = parseChecksumsFile(checksumsText).get(release.asset.name);
+    if (!expectedHash) return { success: false, output: `Missing checksum for ${release.asset.name}.` };
+
+    if (sha256File(downloadedPath) !== expectedHash) {
+      return { success: false, output: `Checksum mismatch for ${release.asset.name}; aborting.` };
+    }
+
+    fs.mkdirSync(path.dirname(context.binaryPath), { recursive: true, mode: 0o700 });
+
+    if (process.platform === "win32") {
+      return applyWindowsUpdate(tempDir, downloadedPath, context, release);
+    }
+
+    const staging = `${context.binaryPath}.new`;
+    fs.copyFileSync(downloadedPath, staging);
+    fs.chmodSync(staging, 0o755);
+    fs.renameSync(staging, context.binaryPath);
+
+    saveScriptInstallMetadata({
+      ...context.metadata,
+      version: release.version,
+      installedAt: new Date().toISOString(),
+    });
+
+    return { success: true, output: `Updated to muonroi-cli ${release.version}.` };
+  } catch (error) {
+    return { success: false, output: error instanceof Error ? error.message : String(error) };
+  } finally {
+    if (process.platform !== "win32") fs.rmSync(tempDir, { recursive: true, force: true });
+  }
+}
+
+export function buildScriptUninstallPlan(
+  options: ScriptUninstallOptions = {},
+  homeDir = os.homedir(),
+): ScriptUninstallPlan | null {
+  const context = getScriptInstallContext(homeDir);
+  if (!context) return null;
+
+  const userDir = getUserDir(homeDir);
+  const removePaths = new Set<string>();
+  const pruneDirs = new Set<string>();
+
+  if (!options.keepConfig && !options.keepData) {
+    removePaths.add(userDir);
+  } else {
+    removePaths.add(context.binaryPath);
+    removePaths.add(getInstallMetadataPath(homeDir));
+    if (!options.keepConfig) for (const f of CONFIG_FILENAMES) removePaths.add(path.join(userDir, f));
+    if (!options.keepData) for (const e of DATA_ENTRIES) removePaths.add(path.join(userDir, e));
+    pruneDirs.add(getScriptInstallDir(homeDir));
+    pruneDirs.add(userDir);
+  }
+
+  return {
+    removePaths: sortForRemoval([...removePaths]),
+    pruneDirs: sortForRemoval([...pruneDirs]),
+    pathCleanup:
+      context.metadata.shellConfigPath && context.metadata.pathCommand
+        ? { configFile: context.metadata.shellConfigPath, command: context.metadata.pathCommand }
+        : undefined,
+  };
+}
+
+export async function runScriptManagedUninstall(options: ScriptUninstallOptions = {}): Promise<ScriptUpdateRunResult> {
+  const plan = buildScriptUninstallPlan(options);
+  if (!plan) return notScriptManaged("uninstall");
+
+  if (options.dryRun) return { success: true, output: formatDryRun(plan, options) };
+
+  if (!options.force) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+      return { success: false, output: "Non-interactive terminal. Re-run with --force." };
+    }
+    if (!(await confirm("Remove muonroi-cli from this machine?"))) {
+      return { success: false, output: "Uninstall cancelled." };
+    }
+  }
+
+  try {
+    if (plan.pathCleanup) removePathLine(plan.pathCleanup.configFile, plan.pathCleanup.command);
+    for (const p of plan.removePaths) fs.rmSync(p, { recursive: true, force: true });
+    for (const d of plan.pruneDirs) removeDirIfEmpty(d);
+    return { success: true, output: "muonroi-cli uninstall complete." };
+  } catch (error) {
+    return { success: false, output: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+function notScriptManaged(action: string): ScriptUpdateRunResult {
+  return {
+    success: false,
+    output: `This install is not script-managed, so \`muonroi-cli ${action}\` cannot proceed. Use the package manager you installed with, or reinstall via install.sh.`,
+  };
+}
+
+function getReleaseTargetForPlatformKey(key: string): ReleaseTarget | null {
+  switch (key) {
+    case "darwin-arm64":
+      return { key, assetName: "muonroi-cli-darwin-arm64", binaryName: "muonroi-cli" };
+    case "darwin-x64":
+      return { key: "darwin-arm64", assetName: "muonroi-cli-darwin-arm64", binaryName: "muonroi-cli" };
+    case "linux-x64":
+      return { key, assetName: "muonroi-cli-linux-x64", binaryName: "muonroi-cli" };
+    case "windows-x64":
+      return { key, assetName: "muonroi-cli-windows-x64.exe", binaryName: "muonroi-cli.exe" };
+    default:
+      return null;
+  }
+}
+
+async function resolveReleaseDownload(target: ReleaseTarget): Promise<ReleaseDownload | null> {
+  const release = await fetchReleaseJson(`${RELEASES_API}/latest`);
+  if (!release) return null;
+  const version = normalizeReleaseVersion(release.tag_name);
+  if (!version) return null;
+
+  const asset = release.assets.find((a) => a.name === target.assetName);
+  const checksums = release.assets.find((a) => a.name === "checksums.txt");
+  if (!asset || !checksums) return null;
+
+  return { version, asset, checksums };
+}
+
+async function fetchReleaseJson(url: string): Promise<GitHubRelease | null> {
+  try {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    const res = await fetch(url, { signal: controller.signal, headers: { Accept: "application/vnd.github+json" } });
+    clearTimeout(timer);
+    return res.ok ? ((await res.json()) as GitHubRelease) : null;
+  } catch {
+    return null;
+  }
+}
+
+function normalizeReleaseVersion(tagName: string): string | null {
+  let version = tagName;
+  if (version.startsWith("muonroi-cli-dev@")) version = version.slice("muonroi-cli-dev@".length);
+  if (version.startsWith("v")) version = version.slice(1);
+  return semverValid(version);
+}
+
+async function downloadBinary(url: string, dest: string): Promise<void> {
+  const res = await fetch(url, { headers: { Accept: "application/octet-stream" } });
+  if (!res.ok) throw new Error(`Download failed (${res.status}) for ${url}`);
+  fs.writeFileSync(dest, Buffer.from(await res.arrayBuffer()));
+}
+
+async function downloadText(url: string): Promise<string> {
+  const res = await fetch(url, { headers: { Accept: "text/plain" } });
+  if (!res.ok) throw new Error(`Download failed (${res.status}) for ${url}`);
+  return await res.text();
+}
+
+function sha256File(filePath: string): string {
+  return createHash("sha256").update(fs.readFileSync(filePath)).digest("hex");
+}
+
+function sortForRemoval(paths: string[]): string[] {
+  return [...new Set(paths)].sort((a, b) => b.length - a.length);
+}
+
+function removeDirIfEmpty(dir: string): void {
+  try {
+    if (fs.existsSync(dir) && fs.readdirSync(dir).length === 0) fs.rmdirSync(dir);
+  } catch {
+    /* best effort */
+  }
+}
+
+function removePathLine(configFile: string, command: string): void {
+  if (!fs.existsSync(configFile)) return;
+  const lines = fs.readFileSync(configFile, "utf8").split(/\r?\n/);
+  fs.writeFileSync(
+    configFile,
+    `${lines
+      .filter((l) => l !== PATH_MARKER && l !== command)
+      .join("\n")
+      .replace(/\n+$/, "")}\n`,
+  );
+}
+
+function formatDryRun(plan: ScriptUninstallPlan, options: ScriptUninstallOptions): string {
+  const lines = ["Dry run — would perform:"];
+  if (plan.pathCleanup) lines.push(`  remove PATH entry from ${plan.pathCleanup.configFile}`);
+  for (const p of plan.removePaths) lines.push(`  remove ${p}`);
+  if (options.keepConfig) lines.push("  keep config files");
+  if (options.keepData) lines.push("  keep data files");
+  return lines.join("\n");
+}
+
+async function confirm(prompt: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${prompt} [y/N] `, (answer) => {
+      rl.close();
+      resolve(/^y(es)?$/i.test(answer.trim()));
+    });
+  });
+}
+
+function applyWindowsUpdate(
+  tempDir: string,
+  downloadedPath: string,
+  context: ScriptInstallContext,
+  release: ReleaseDownload,
+): ScriptUpdateRunResult {
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    "Start-Sleep -Seconds 2",
+    `Move-Item -LiteralPath '${esc(downloadedPath)}' -Destination '${esc(context.binaryPath)}' -Force`,
+  ].join("\n");
+
+  const scriptPath = path.join(tempDir, "apply-update.ps1");
+  fs.writeFileSync(scriptPath, script);
+
+  saveScriptInstallMetadata({ ...context.metadata, version: release.version, installedAt: new Date().toISOString() });
+
+  const child = spawn("powershell.exe", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", scriptPath], {
+    detached: true,
+    stdio: "ignore",
+  });
+  child.unref();
+
+  return {
+    success: true,
+    output: `Updated to muonroi-cli ${release.version}. Restart the CLI to use the new version.`,
+  };
+}
+
+function esc(s: string): string {
+  return s.replace(/'/g, "''");
+}

package/src/utils/instructions.test.ts

@@ -0,0 +1,84 @@
+import fs from "fs";
+import os from "os";
+import path from "path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+
+function makeTempDir(prefix: string): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), prefix));
+}
+
+function writeFile(filePath: string, content: string): void {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content);
+}
+
+async function importLoadCustomInstructions(mockedHome?: string) {
+  vi.resetModules();
+  vi.doUnmock("os");
+
+  if (mockedHome) {
+    process.env.HOME = mockedHome;
+    vi.doMock("os", async () => {
+      const actual = await vi.importActual<typeof import("os")>("os");
+      return {
+        ...actual,
+        homedir: () => mockedHome,
+      };
+    });
+  }
+
+  const mod = await import("./instructions");
+  return mod.loadCustomInstructions;
+}
+
+const originalHome = process.env.HOME;
+
+describe("loadCustomInstructions", () => {
+  afterEach(() => {
+    process.env.HOME = originalHome;
+    vi.restoreAllMocks();
+    vi.resetModules();
+    vi.doUnmock("os");
+  });
+
+  it("returns null when no instruction files exist", async () => {
+    const home = makeTempDir("muonroi-home-");
+    const cwd = makeTempDir("muonroi-cwd-");
+    const loadCustomInstructions = await importLoadCustomInstructions(home);
+
+    expect(loadCustomInstructions(cwd)).toBeNull();
+  });
+
+  it("loads global plus repo-chain AGENTS files in order", async () => {
+    const home = makeTempDir("muonroi-home-");
+    const repoRoot = makeTempDir("muonroi-repo-");
+    const cwd = path.join(repoRoot, "pkg", "feature");
+    fs.mkdirSync(path.join(repoRoot, ".git"));
+    fs.mkdirSync(cwd, { recursive: true });
+
+    writeFile(path.join(home, ".muonroi-cli", "AGENTS.md"), "global instructions");
+    writeFile(path.join(repoRoot, "AGENTS.md"), "root instructions");
+    writeFile(path.join(repoRoot, "pkg", "AGENTS.md"), "pkg instructions");
+    writeFile(path.join(repoRoot, "pkg", "feature", "AGENTS.md"), "feature instructions");
+    const loadCustomInstructions = await importLoadCustomInstructions(home);
+
+    expect(loadCustomInstructions(cwd)).toBe(
+      ["global instructions", "root instructions", "pkg instructions", "feature instructions"].join("\n\n"),
+    );
+  });
+
+  it("prefers AGENTS.override.md over AGENTS.md in the same directory", async () => {
+    const home = makeTempDir("muonroi-home-");
+    const repoRoot = makeTempDir("muonroi-repo-");
+    const cwd = path.join(repoRoot, "nested");
+    fs.mkdirSync(path.join(repoRoot, ".git"));
+    fs.mkdirSync(cwd, { recursive: true });
+
+    writeFile(path.join(repoRoot, "AGENTS.md"), "root instructions");
+    writeFile(path.join(repoRoot, "nested", "AGENTS.md"), "nested base instructions");
+    writeFile(path.join(repoRoot, "nested", "AGENTS.override.md"), "nested override instructions");
+    const loadCustomInstructions = await importLoadCustomInstructions(home);
+
+    expect(loadCustomInstructions(cwd)).toBe(["root instructions", "nested override instructions"].join("\n\n"));
+  });
+});

package/src/utils/instructions.ts

@@ -0,0 +1,116 @@
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+import { executeEventHooks } from "../hooks/index";
+import type { InstructionsLoadedHookInput } from "../hooks/types";
+import { findGitRoot } from "./git-root";
+
+const instructionsHookFiredFor = new Set<string>();
+
+// --- Instructions cache ---
+const _instructionsCache = new Map<string, { content: string | null; hash: string; cachedAt: number }>();
+const INSTRUCTIONS_CACHE_TTL_MS = 60_000; // 1 minute TTL — files rarely change mid-session
+
+function computeHash(parts: string[]): string {
+  const joined = parts.join("|");
+  return `${joined.length}:${joined.slice(0, 50)}:${joined.slice(-50)}`;
+}
+
+/** Clear the instructions cache (for tests). */
+export function resetInstructionsCache(): void {
+  _instructionsCache.clear();
+}
+
+function readNonEmptyFile(filePath: string): string | null {
+  try {
+    if (!fs.existsSync(filePath)) return null;
+    const text = fs.readFileSync(filePath, "utf-8").trim();
+    return text.length > 0 ? text : null;
+  } catch {
+    return null;
+  }
+}
+
+function directoryChain(fromRoot: string, toCwd: string): string[] {
+  const rel = path.relative(fromRoot, toCwd);
+  if (rel === "") return [fromRoot];
+  if (rel.startsWith("..")) return [toCwd];
+
+  const segments = rel.split(path.sep).filter(Boolean);
+  const chain: string[] = [];
+  let acc = fromRoot;
+  chain.push(acc);
+  for (const segment of segments) {
+    acc = path.join(acc, segment);
+    chain.push(acc);
+  }
+  return chain;
+}
+
+function loadAgentsSegments(canonicalCwd: string): string[] {
+  const segments: string[] = [];
+
+  const globalAgents = readNonEmptyFile(path.join(os.homedir(), ".muonroi-cli", "AGENTS.md"));
+  if (globalAgents) segments.push(globalAgents);
+
+  const root = findGitRoot(canonicalCwd) ?? canonicalCwd;
+  for (const dir of directoryChain(root, canonicalCwd)) {
+    const overridePath = path.join(dir, "AGENTS.override.md");
+    if (fs.existsSync(overridePath)) {
+      const text = readNonEmptyFile(overridePath);
+      if (text) segments.push(text);
+      continue;
+    }
+    const text = readNonEmptyFile(path.join(dir, "AGENTS.md"));
+    if (text) segments.push(text);
+  }
+
+  return segments;
+}
+
+export function loadCustomInstructions(cwd: string): string | null {
+  let canonical: string;
+  try {
+    canonical = fs.realpathSync.native(cwd);
+  } catch {
+    canonical = path.resolve(cwd);
+  }
+
+  // Check cache first
+  const now = Date.now();
+  const cached = _instructionsCache.get(canonical);
+  if (cached && now - cached.cachedAt < INSTRUCTIONS_CACHE_TTL_MS) {
+    // Still fire hook on first call even when returning cached content
+    if (cached.content !== null && !instructionsHookFiredFor.has(canonical)) {
+      instructionsHookFiredFor.add(canonical);
+      const hookInput: InstructionsLoadedHookInput = {
+        hook_event_name: "InstructionsLoaded",
+        files_loaded: cached.content.split("\n\n").length,
+        cwd: canonical,
+      };
+      executeEventHooks(hookInput, canonical).catch(() => {});
+    }
+    return cached.content;
+  }
+
+  const parts: string[] = [...loadAgentsSegments(canonical)];
+
+  if (parts.length === 0) {
+    _instructionsCache.set(canonical, { content: null, hash: "", cachedAt: now });
+    return null;
+  }
+
+  if (!instructionsHookFiredFor.has(canonical)) {
+    instructionsHookFiredFor.add(canonical);
+    const hookInput: InstructionsLoadedHookInput = {
+      hook_event_name: "InstructionsLoaded",
+      files_loaded: parts.length,
+      cwd: canonical,
+    };
+    executeEventHooks(hookInput, canonical).catch(() => {});
+  }
+
+  const content = parts.join("\n\n");
+  _instructionsCache.set(canonical, { content, hash: computeHash(parts), cachedAt: now });
+  return content;
+}