totemlayer 0.1.4 → 0.1.5

package/bin/agent-setup.mjs

@@ -0,0 +1,659 @@
+import { execFile } from "node:child_process";
+import { readFile, stat } from "node:fs/promises";
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { parseArgs, promisify, stripVTControlCharacters } from "node:util";
+
+import { readAgentCredential, readAgentProfile, saveAgentProfile } from "./agent-profile.mjs";
+import { installTotemMcp, installManagedTotemMcp, inspectManagedTotemMcp } from "./mcp-install.mjs";
+import { localModelEndpoint } from "./local-model-provider.mjs";
+import { installedClientInvocation, localClientEnvironment } from "./platform-client.mjs";
+import { inspectLocalRepository } from "./repository.mjs";
+import { Totem } from "./sdk/index.js";
+
+const execute = promisify(execFile);
+const ORIGIN = "https://totemlayer.com";
+const KEY_LIMIT = 8192;
+
+export const AGENT_SETUP_HELP = `Connect your agent once
+
+  totem setup [--profile default] [--provider qwen-local|codex|claude]
+    [--key-file <private-file>] [--base-url <Totem-origin>] [--agent-id <expected-id>]
+    [--repo-root <checkout>]... [--model qwen3.5-9b]
+    [--qwen-url http://127.0.0.1:8087/v1] [--install-mcp] [--replace] [--json]
+  totem status [--profile default] [--json]
+
+In a terminal, setup can ask for a hidden connection key. Otherwise use --key-file.
+Keys are never accepted as command arguments. Repeating unchanged setup is safe.
+--replace explicitly replaces this profile's connection settings and credential.
+--repo-root approves a checkout for this profile; omit it for connection-only setup.
+--install-mcp connects Codex or Claude using the saved private key-file path.
+Setup does not download models or start workers. Codex/Claude MCP connections
+provide tools; automatic Mission execution currently uses the local Qwen worker.
+Status only reads readiness; it never claims work or sends a heartbeat.
+`;
+
+function fail(message, code) {
+  throw Object.assign(new Error(message), { setupSafe: true, ...(code ? { code } : {}) });
+}
+
+function parse(args, status = false) {
+  let parsed;
+  try {
+    parsed = parseArgs({
+      args,
+      strict: true,
+      allowPositionals: false,
+      options: {
+        help: { type: "boolean", short: "h" },
+        json: { type: "boolean" },
+        profile: { type: "string", default: "default" },
+        ...(!status && {
+          provider: { type: "string" },
+          "key-file": { type: "string" },
+          "base-url": { type: "string" },
+          "agent-id": { type: "string" },
+          "repo-root": { type: "string", multiple: true },
+          model: { type: "string" },
+          "qwen-url": { type: "string" },
+          "install-mcp": { type: "boolean" },
+          replace: { type: "boolean" },
+        }),
+      },
+    });
+  } catch {
+    fail("Unknown or incomplete option. Run totem setup --help. Never pass a key as an argument.");
+  }
+  const options = parsed.values;
+  if (
+    !/^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(options.profile) ||
+    options.profile.length > 64 ||
+    /^(?:con|prn|aux|nul|com[0-9]|lpt[0-9])$/.test(options.profile)
+  )
+    fail("Choose a profile name using lowercase letters, numbers and single hyphens.");
+  if (
+    options["agent-id"] &&
+    !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/i.test(options["agent-id"])
+  )
+    fail("The expected agent ID must be a valid UUID.");
+  return options;
+}
+
+function origin(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    fail("Choose a valid HTTPS Totem origin, or HTTP loopback for local development.");
+  }
+  if (
+    url.username ||
+    url.password ||
+    url.search ||
+    url.hash ||
+    url.pathname !== "/" ||
+    (url.protocol !== "https:" &&
+      !(url.protocol === "http:" && ["localhost", "127.0.0.1", "[::1]"].includes(url.hostname)))
+  )
+    fail("Choose a credential-free HTTPS Totem origin, or HTTP loopback for local development.");
+  return url.origin;
+}
+
+function credential(value) {
+  const key = typeof value === "string" ? value.trim() : "";
+  if (!key || Buffer.byteLength(key) > KEY_LIMIT || /\s|[\x00-\x1f\x7f]/.test(key))
+    fail("The connection key must be one nonempty value no larger than 8 KiB.");
+  return key;
+}
+
+async function keyFromFile(path) {
+  try {
+    const info = await stat(path);
+    if (!info.isFile() || !info.size || info.size > KEY_LIMIT)
+      fail("Use a nonempty regular key file no larger than 8 KiB.");
+    if (process.platform !== "win32" && (info.mode & 0o077) !== 0)
+      fail("The key file must be private. Set its permissions to 0600 before setup.");
+    return credential(await readFile(path, "utf8"));
+  } catch (error) {
+    if (error?.setupSafe) throw error;
+    fail("The key file could not be read. Check its path and permissions.");
+  }
+}
+
+async function ask(question, io) {
+  const reader = createInterface({ input: io.stdin, output: io.stderr });
+  try {
+    return (await reader.question(question)).trim();
+  } finally {
+    reader.close();
+  }
+}
+
+export async function readHiddenCredential({
+  stdin = process.stdin,
+  stderr = process.stderr,
+} = {}) {
+  if (!stdin.isTTY || typeof stdin.setRawMode !== "function")
+    fail("Noninteractive setup requires --key-file with a private connection key file.");
+  stderr.write("Paste your Totem connection key (hidden): ");
+  const wasRaw = Boolean(stdin.isRaw);
+  const wasPaused = stdin.isPaused();
+  stdin.setRawMode(true);
+  stdin.resume();
+  try {
+    return await new Promise((resolveKey, reject) => {
+      let value = "";
+      const cleanup = () => {
+        stdin.removeListener("data", data);
+        stdin.removeListener("end", ended);
+        stdin.removeListener("error", ended);
+      };
+      const finish = (error) => {
+        cleanup();
+        if (error) reject(error);
+        else resolveKey(value);
+      };
+      const ended = () =>
+        finish(Object.assign(new Error("Key entry was canceled."), { setupSafe: true }));
+      const data = (chunk) => {
+        for (const character of chunk.toString("utf8")) {
+          if (character === "\u0003" || character === "\u0004") return ended();
+          if (character === "\r" || character === "\n") return finish();
+          if (character === "\u007f" || character === "\b") value = value.slice(0, -1);
+          else value += character;
+          if (Buffer.byteLength(value) > KEY_LIMIT) return ended();
+        }
+      };
+      stdin.on("data", data);
+      stdin.once("end", ended);
+      stdin.once("error", ended);
+    });
+  } finally {
+    stdin.setRawMode(wasRaw);
+    if (wasPaused) stdin.pause();
+    stderr.write("\n");
+  }
+}
+
+function dependencies(options) {
+  return {
+    env: options.env ?? options.environment ?? process.env,
+    stdin: process.stdin,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    createClient: (config) => new Totem({ ...config, timeoutMs: 5000, maxRetries: 0 }),
+    fetch: globalThis.fetch,
+    inspectRepository: inspectLocalRepository,
+    installMcp: installTotemMcp,
+    ask,
+    readSecret: readHiddenCredential,
+    runClient: async (client, args, environment) => {
+      const invocation =
+        process.platform === "win32"
+          ? installedClientInvocation(client, args, environment)
+          : { command: client, args };
+      return execute(invocation.command, invocation.args, {
+        env: localClientEnvironment(environment),
+        timeout: 5000,
+        maxBuffer: 64 * 1024,
+        encoding: "utf8",
+      });
+    },
+    ...options,
+  };
+}
+
+function safeOutput(value, secret) {
+  let text = typeof value === "string" ? value : JSON.stringify(value);
+  if (secret) text = text.split(secret).join("[REDACTED]");
+  return stripVTControlCharacters(text);
+}
+
+function identityError(error) {
+  return error?.status === 401 || error?.status === 403
+    ? "The connection key was rejected. For a saved profile, rerun setup with --replace to enter a new key, or use --replace --key-file with the replacement key."
+    : "Totem identity could not be verified. Check the origin, connection key, and server availability.";
+}
+
+async function verifiedIdentity(client) {
+  let identity;
+  try {
+    identity = await client.agent({ signal: AbortSignal.timeout(5000) });
+  } catch (error) {
+    fail(
+      identityError(error),
+      error?.status === 401 || error?.status === 403 ? "CONNECTION_KEY_REJECTED" : undefined,
+    );
+  }
+  if (
+    !identity ||
+    typeof identity.id !== "string" ||
+    !identity.id ||
+    typeof identity.address !== "string" ||
+    !/^[^\s@]+@[^\s@]+$/.test(identity.address) ||
+    !["SANDBOX", "PRODUCTION"].includes(identity.environment) ||
+    (identity.status && !["ACTIVE", "OFFLINE"].includes(identity.status))
+  )
+    fail("Totem did not return an active agent identity. Check this agent in Totem.");
+  return identity;
+}
+
+async function selectedRepositories(roots, previous, io) {
+  if (!roots) return previous?.repositoryRoots ?? [];
+  const repositories = [];
+  for (const value of roots) {
+    const root = resolve(value);
+    let info;
+    try {
+      info = await io.inspectRepository({ TOTEM_REPOSITORY_ROOT: root });
+    } catch {
+      fail("A selected checkout could not be verified. Check its Git origin and permissions.");
+    }
+    if (!info.clean || !info.currentBranch)
+      fail("Choose a clean checkout on a named branch before approving it for Mission work.");
+    if (repositories.some((entry) => entry.repositoryId === info.repository))
+      fail("Choose one checkout for each repository in this profile.");
+    repositories.push({ repositoryId: info.repository, root });
+  }
+  return repositories;
+}
+
+async function configureMcp(profile, previous, io) {
+  return installManagedTotemMcp(profile, previous, io.env, {
+    runClient: io.runClient,
+    install: io.installMcp,
+  });
+}
+
+export async function agentSetupMain(args, options = {}) {
+  const io = dependencies(options);
+  let key;
+  const json = args.includes("--json");
+  try {
+    const flags = parse(args);
+    if (flags.help) {
+      io.stdout.write(AGENT_SETUP_HELP);
+      return 0;
+    }
+    let previous;
+    try {
+      previous = await readAgentProfile(flags.profile, { environment: io.env });
+    } catch (error) {
+      if (!["ENOENT", "AGENT_PROFILE_NOT_FOUND"].includes(error?.code))
+        fail("The saved profile could not be read safely. Inspect it before replacing it.");
+    }
+    const interactive = Boolean(io.stdin.isTTY && !flags.json);
+    let mode = flags.provider ?? previous?.client ?? (previous ? "qwen-local" : undefined);
+    if (!mode && interactive) {
+      const choice = await io.ask("Connect with 1) local Qwen, 2) Codex, or 3) Claude [1]: ", io);
+      mode = { "": "qwen-local", 1: "qwen-local", 2: "codex", 3: "claude" }[choice] ?? choice;
+    }
+    mode ??= "qwen-local";
+    if (!["qwen-local", "codex", "claude"].includes(mode))
+      fail("Choose qwen-local, codex, or claude.");
+    if (flags["install-mcp"] && mode === "qwen-local")
+      fail("Choose Codex or Claude before using --install-mcp.");
+    let baseUrl = flags["base-url"] ?? previous?.baseUrl ?? io.env.TOTEM_BASE_URL;
+    if (!baseUrl && interactive) baseUrl = await io.ask(`Totem origin [${ORIGIN}]: `, io);
+    baseUrl = origin(baseUrl || ORIGIN);
+    const originChanged = previous && previous.baseUrl !== baseUrl;
+    if (originChanged && !flags.replace)
+      fail(
+        "This profile is bound to another origin. Choose a new profile or explicitly use --replace with a key for the new origin.",
+      );
+    let selectedRoots = flags["repo-root"];
+    if (!selectedRoots && !previous && interactive && mode === "qwen-local") {
+      const chosen = await io.ask(
+        "Checkout to approve for coding Missions (leave blank for connection only): ",
+        io,
+      );
+      if (chosen) selectedRoots = [chosen];
+    }
+    const qwenUrl = flags["qwen-url"] ?? previous?.qwenUrl ?? "http://127.0.0.1:8087/v1";
+    try {
+      localModelEndpoint("qwen-local", { qwenUrl });
+    } catch {
+      fail("Choose a credential-free loopback HTTP /v1 endpoint for Qwen.");
+    }
+    const model = flags.model ?? previous?.model ?? "qwen3.5-9b";
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:/-]{0,127}$/.test(model))
+      fail("Choose a valid installed local model name.");
+    const keyFile = flags["key-file"] ?? io.env.TOTEM_NETWORK_API_KEY_FILE;
+    if (keyFile) key = await keyFromFile(keyFile);
+    else if (previous && !originChanged) key = credential(await readAgentCredential(previous));
+    else {
+      if (!interactive)
+        fail("Noninteractive setup requires --key-file with a private connection key file.");
+      key = credential(await io.readSecret(io));
+    }
+    let identity;
+    try {
+      identity = await verifiedIdentity(io.createClient({ apiKey: key, baseUrl }));
+    } catch (error) {
+      if (
+        !interactive ||
+        keyFile ||
+        (previous && !flags.replace) ||
+        error?.code !== "CONNECTION_KEY_REJECTED"
+      )
+        throw error;
+      io.stderr.write("The key was rejected. Enter a replacement key for this profile.\n");
+      key = credential(await io.readSecret(io));
+      identity = await verifiedIdentity(io.createClient({ apiKey: key, baseUrl }));
+    }
+    if (flags["agent-id"] && identity.id !== flags["agent-id"])
+      fail(
+        "This key belongs to a different agent than the selected agent. Use that agent's own connection key.",
+      );
+    if (
+      previous &&
+      !flags.replace &&
+      (previous.agentId !== identity.id ||
+        previous.baseUrl !== baseUrl ||
+        previous.address !== identity.address ||
+        previous.environment !== identity.environment)
+    )
+      fail(
+        "This profile is bound to another agent or origin. Choose a new profile or explicitly use --replace.",
+      );
+    const repositoryRoots = await selectedRepositories(selectedRoots, previous, io);
+    let profile;
+    try {
+      profile = await saveAgentProfile(
+        flags.profile,
+        {
+          baseUrl,
+          agentId: identity.id,
+          address: identity.address,
+          environment: identity.environment,
+          provider: "qwen-local",
+          model,
+          qwenUrl,
+          repositoryRoots,
+          ...(mode === "qwen-local" ? {} : { client: mode }),
+        },
+        key,
+        { environment: io.env, replace: flags.replace === true },
+      );
+    } catch (error) {
+      if (error?.code === "AGENT_PROFILE_RUNNING")
+        fail(
+          "Stop this agent before replacing its connection or settings. Run totem stop for this profile and wait for it to stop.",
+        );
+      if (error?.code === "AGENT_PROFILE_BUSY")
+        fail(
+          "Another setup or worker start may be updating this profile. Wait for it to finish. If this persists after those processes have stopped, inspect this profile's private profile.lock file before recovery. The lock is never cleared automatically.",
+        );
+      fail(
+        "The profile could not be saved safely. If its settings changed, choose a new profile or explicitly use --replace.",
+      );
+    }
+    let install = Boolean(flags["install-mcp"]);
+    if (profile.client && interactive && !install && previous?.client !== profile.client)
+      install = /^(y|yes)$/i.test(
+        await io.ask(`Add the saved connection to ${profile.client}? [y/N]: `, io),
+      );
+    const mcp = install ? await configureMcp(profile, previous, io) : undefined;
+    const next = profile.client
+      ? "Use totem_get_identity in your AI app. MCP tools alone do not execute Missions; automatic Missions currently need the local Qwen worker."
+      : repositoryRoots.length
+        ? `Run totem start --profile ${profile.profileName} to keep this agent available for assigned Missions.`
+        : `Run totem start --profile ${profile.profileName} for approved Missions. Coding Missions also need a checkout: run setup with an explicit --repo-root and --replace before assigning code work.`;
+    const report = {
+      ok: !mcp || mcp.state !== "needs_attention",
+      profile: profile.profileName,
+      agent: identity.address,
+      origin: baseUrl,
+      connection: "verified",
+      mode,
+      approvedRepositories: repositoryRoots.length,
+      worker: "not_started_by_setup",
+      ...(mcp ? { mcp } : {}),
+      next,
+    };
+    io.stdout.write(
+      safeOutput(
+        flags.json
+          ? report
+          : `Connected ${identity.address} at ${baseUrl}.\n${mcp ? `${mcp.message}\n` : ""}${next}\n`,
+        key,
+      ) + (flags.json ? "\n" : ""),
+    );
+    return report.ok ? 0 : 1;
+  } catch (error) {
+    const message = error?.setupSafe
+      ? error.message
+      : "Setup could not complete safely. Check the saved profile, private key file, and connection settings.";
+    const output = json ? { ok: false, error: { code: "SETUP_FAILED", message } } : `${message}\n`;
+    (json ? io.stdout : io.stderr).write(safeOutput(output, key) + (json ? "\n" : ""));
+    return 1;
+  }
+}
+
+async function modelReadiness(profile, io) {
+  try {
+    localModelEndpoint("qwen-local", { qwenUrl: profile.qwenUrl });
+    const response = await io.fetch(`${profile.qwenUrl.replace(/\/$/, "")}/models`, {
+      method: "GET",
+      redirect: "error",
+      signal: AbortSignal.timeout(5000),
+    });
+    if (!response.ok) throw new Error();
+    const reader = response.body?.getReader();
+    if (!reader) throw new Error();
+    const chunks = [];
+    let length = 0;
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        length += value.byteLength;
+        if (length > 256 * 1024) throw new Error();
+        chunks.push(Buffer.from(value));
+      }
+    } finally {
+      await reader.cancel().catch(() => {});
+    }
+    const body = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+    if (!Array.isArray(body.data) || !body.data.some((entry) => entry?.id === profile.model))
+      return {
+        state: "model_missing",
+        message:
+          "The model server is reachable but the configured model is not listed. Start it with the saved model alias.",
+      };
+    return {
+      state: "available",
+      message: "The local server lists the configured model. No generation was requested.",
+    };
+  } catch {
+    return {
+      state: "unavailable",
+      message:
+        "Start the local Qwen server at the saved endpoint, then check status again. No model is downloaded automatically.",
+    };
+  }
+}
+
+export async function agentStatusMain(args, options = {}) {
+  const io = dependencies(options);
+  let key;
+  const json = args.includes("--json");
+  try {
+    const flags = parse(args, true);
+    if (flags.help) {
+      io.stdout.write(AGENT_SETUP_HELP);
+      return 0;
+    }
+    const profile = await readAgentProfile(flags.profile, { environment: io.env });
+    key = await readAgentCredential(profile);
+    const checks = {};
+    try {
+      const identity = await verifiedIdentity(
+        io.createClient({ apiKey: key, baseUrl: profile.baseUrl }),
+      );
+      if (
+        identity.id !== profile.agentId ||
+        identity.address !== profile.address ||
+        identity.environment !== profile.environment
+      )
+        fail(
+          "The saved key no longer matches this profile's agent. Run setup with a separate profile or explicitly replace it.",
+        );
+      checks.credential = {
+        state: "verified",
+        message: "The saved key identifies the expected agent.",
+      };
+    } catch (error) {
+      checks.credential = {
+        state: "failed",
+        message: error?.setupSafe
+          ? error.message
+          : "The saved agent identity could not be verified.",
+      };
+    }
+    checks.repositories = {
+      state: profile.repositoryRoots.length ? "verified" : "not_configured",
+      message: profile.repositoryRoots.length
+        ? "Approved repository origins match their saved checkouts."
+        : "Connection-only profile. Add an explicit --repo-root with setup before coding Missions.",
+    };
+    for (const approved of profile.repositoryRoots) {
+      try {
+        const local = await io.inspectRepository({ TOTEM_REPOSITORY_ROOT: approved.root });
+        if (local.repository !== approved.repositoryId) throw new Error();
+        if (!local.clean || !local.currentBranch)
+          checks.repositories = {
+            state: "needs_attention",
+            message:
+              "An approved checkout is dirty or detached. Inspect it before Mission work; status will not reset it.",
+          };
+      } catch {
+        checks.repositories = {
+          state: "mismatch",
+          message:
+            "An approved checkout is missing or its origin changed. Inspect it and update setup explicitly.",
+        };
+        break;
+      }
+    }
+    checks.model = profile.client
+      ? {
+          state: "not_required",
+          message:
+            "Your AI app supplies its own model. This MCP profile does not enable automatic Mission execution.",
+        }
+      : await modelReadiness(profile, io);
+    if (profile.client) {
+      try {
+        await io.runClient(profile.client, ["--version"], io.env);
+        checks.mcp = await inspectManagedTotemMcp(profile, io.env, { runClient: io.runClient });
+      } catch {
+        checks.mcp = {
+          state: "client_missing",
+          message:
+            "Install and sign in to the selected AI client, then run setup with --install-mcp.",
+        };
+      }
+    }
+    checks.worker = profile.client
+      ? {
+          state: "not_supported",
+          message:
+            "This profile connects an AI app through MCP. Use a separate local Qwen profile for automatic Mission execution.",
+        }
+      : {
+          state: "not_checked",
+          message:
+            "A verified connection does not prove a worker is running. Use totem start for this profile; status has not started a worker.",
+        };
+    if (io.readRuntimeStatus && !profile.client) {
+      try {
+        const worker = await io.readRuntimeStatus(profile);
+        const phases = [
+          "starting",
+          "connected",
+          "working",
+          "waiting",
+          "blocked",
+          "stopped",
+          "failed",
+          "not_started",
+          "interrupted",
+          "unresponsive",
+          "reconnecting",
+          "stopping",
+        ];
+        const phase = phases.includes(worker?.phase) ? worker.phase : undefined;
+        const state = phase
+          ? worker.running === true && ["connected", "working", "waiting"].includes(phase)
+            ? "running"
+            : phase === "starting" && worker.running === true
+              ? "starting"
+              : ["stopped", "not_started"].includes(phase)
+                ? phase
+                : "needs_attention"
+          : ["running", "stopped", "starting", "needs_attention", "not_started"].includes(
+                worker?.state,
+              )
+            ? worker.state
+            : "needs_attention";
+        checks.worker = {
+          state,
+          ...(phase ? { phase } : {}),
+          message:
+            state === "running"
+              ? "The local Mission worker reports a current process heartbeat and a connected work phase."
+              : phase === "reconnecting"
+                ? "The worker is reconnecting to Totem. Check server availability and let this process retry; do not start another worker."
+                : phase === "stopping"
+                  ? "The worker is stopping and preserving progress. Wait for it to stop before changing setup or restarting."
+                  : phase === "blocked"
+                    ? "The running worker has a Mission blocker. Open Missions to resolve it; starting another worker will not resolve the blocker."
+                    : phase === "unresponsive"
+                      ? "The worker process is present but its status is stale. Inspect or stop it before starting another worker."
+                      : "The local worker is not confirmed ready. Check it with totem start for this profile.",
+        };
+      } catch {
+        checks.worker = {
+          state: "needs_attention",
+          message: "The local worker status could not be read safely.",
+        };
+      }
+    }
+    const ok = checks.credential.state === "verified";
+    const missionsReady =
+      !profile.client &&
+      ok &&
+      checks.model.state === "available" &&
+      checks.worker.state === "running";
+    const report = {
+      ok,
+      profile: profile.profileName,
+      agent: profile.address,
+      origin: profile.baseUrl,
+      checks,
+      missionsReady,
+      codingReady: missionsReady && checks.repositories.state === "verified",
+    };
+    const output = flags.json
+      ? report
+      : `${profile.address} at ${profile.baseUrl}\n${Object.entries(checks)
+          .map(([name, check]) => `${name}: ${check.state}. ${check.message}`)
+          .join("\n")}\n`;
+    io.stdout.write(safeOutput(output, key) + (flags.json ? "\n" : ""));
+    return ok ? 0 : 1;
+  } catch (error) {
+    const message = error?.setupSafe
+      ? error.message
+      : "The profile or its private key could not be read safely. Run totem setup to connect this agent.";
+    (json ? io.stdout : io.stderr).write(
+      safeOutput(
+        json ? { ok: false, error: { code: "STATUS_FAILED", message } } : `${message}\n`,
+        key,
+      ) + (json ? "\n" : ""),
+    );
+    return 1;
+  }
+}
+
+export const agentDoctorMain = agentStatusMain;