@citeark/agent 0.3.20

package/src/sandbox/docker.mjs

@@ -0,0 +1,363 @@
+import { recordResearchCleanup } from '../workspace/control.mjs';
+import { hasSessionEvents, createRuntimeStream } from '../terminal/events.mjs';
+import path from "node:path";
+
+import {
+  recordRunnerProcessFinished,
+  recordRunnerProcessStarted,
+} from "../execution/runner-audit.mjs";
+import { captureProcess, runProcess } from "../process.mjs";
+import { previewProviderSession } from "../provider/relay.mjs";
+import { openCodeModelDefinition } from "../runtime/opencode.mjs";
+import { CiteArkError, printableCommand, writeJson, readJson, pathExists } from "../util.mjs";
+
+export function buildDockerRun({
+  bundle,
+  runtimeCommand,
+  runtimeArgs,
+  attempt,
+  providerSession = previewProviderSession(bundle.runtimeAgent),
+  egressSession,
+}) {
+  const agent = bundle.runtimeAgent;
+  const environment = bundle.executionEnvironment ?? bundle.runtimeTask.environment;
+  const containerName = `${bundle.runId}-a${attempt}`
+    .toLowerCase()
+    .replaceAll(/[^a-z0-9_.-]/g, "-")
+    .slice(0, 63);
+  const containerUser = `${process.getuid?.() ?? 1000}:${process.getgid?.() ?? 1000}`;
+  const args = [
+    "run",
+    "--rm",
+    "--name",
+    containerName,
+    "--user",
+    containerUser,
+    "--workdir",
+    "/job/workspace/repository",
+    "--cpus",
+    String(environment.cpus),
+    "--memory",
+    `${environment.memoryGb}g`,
+    "--shm-size",
+    `${environment.shmGb}g`,
+    "--pids-limit",
+    "4096",
+    "--add-host",
+    "host.docker.internal:host-gateway",
+    "--env",
+    "HOME=/job/runtime-home",
+    "--volume",
+    `${bundle.directories.input}:/job/input:ro`,
+    "--volume",
+    `${bundle.directories.workspace}:/job/workspace:rw`,
+    "--volume",
+    `${bundle.directories.output}:/job/output:rw`,
+    "--volume",
+    `${bundle.directories.runtimeHome}:/job/runtime-home:rw`,
+  ];
+  args.push(...providerDockerEnvironment(agent, providerSession));
+  if (egressSession?.containerProxyUrl) {
+    args.push(
+      "--env",
+      `HTTP_PROXY=${egressSession.containerProxyUrl}`,
+      "--env",
+      `HTTPS_PROXY=${egressSession.containerProxyUrl}`,
+      "--env",
+      `http_proxy=${egressSession.containerProxyUrl}`,
+      "--env",
+      `https_proxy=${egressSession.containerProxyUrl}`,
+      "--env",
+      "NO_PROXY=127.0.0.1,localhost,host.docker.internal",
+      "--env",
+      "no_proxy=127.0.0.1,localhost,host.docker.internal",
+    );
+  }
+  if (environment.gpu === "all") {
+    args.push("--gpus", "all");
+  }
+  if (bundle.deploymentHandoff) {
+    for (const [key, target] of Object.entries({ assets: 'assets', runtimeCache: 'runtime-cache', runtimeVenv: 'runtime-venv' })) {
+      args.push('--volume', `${bundle.directories[key]}:/job/${target}:rw`);
+    }
+    args.push(environment.image, 'bash', '/job/input/local-runtime.sh', runtimeCommand, ...runtimeArgs);
+  } else args.push(environment.image, runtimeCommand, ...runtimeArgs);
+  return {
+    command: "docker",
+    args,
+    containerName,
+    printable: printableCommand("docker", sanitizeDockerArgs(args)),
+    credentialRelay: {
+      mode: providerSession.mode,
+      protocol: providerSession.apiProtocol,
+      source: providerSession.credentialSource,
+      injectedIntoSandbox: providerSession.credentialInjectedIntoSandbox,
+    },
+    networkEgress: {
+      mode: egressSession?.mode ?? "direct",
+      allowedHosts: egressSession?.allowedHosts ?? [],
+    },
+  };
+}
+
+
+export async function runDockerInvocation(
+  invocation,
+  { bundle, attempt, timeoutMs },
+) {
+  const tracePath = path.join(bundle.directories.execution, "trace.jsonl");
+  const stderrPath = path.join(bundle.directories.execution, "claude-stderr.log");
+  const marker = {
+    type: "citeark.attempt_started",
+    run_id: bundle.runId,
+    attempt,
+    recorded_at: new Date().toISOString(),
+  };
+  const { appendFile } = await import("node:fs/promises");
+  await appendFile(tracePath, `${JSON.stringify(marker)}\n`);
+
+  const runnerEvent = await recordRunnerProcessStarted({
+    executionDirectory: bundle.directories.execution,
+    runId: bundle.runId,
+    attempt,
+    executor: "docker",
+    command: invocation.command,
+    args: sanitizeDockerArgs(invocation.args),
+    workingDirectory: "/job/workspace/repository",
+    captureBoundary: "host-runner-outside-agent-mounts",
+  });
+
+  const stream = hasSessionEvents() ? createRuntimeStream({ source: `${bundle.runId}:${attempt}`, runtime: bundle.runtimeAgent.runtime }) : null;
+  const result = await runProcess(invocation.command, invocation.args, {
+    env: sanitizedHostRuntimeEnvironment(),
+    timeoutMs,
+    stdoutPath: tracePath,
+    stderrPath,
+    append: true,
+    printStdout: false,
+    onStdout: stream ? chunk => stream.write(chunk) : undefined,
+    onTimeout: async () => {
+      const stopped = await captureProcess('docker', ['stop', '--time', '5', invocation.containerName]);
+      const absent = stopped.code ? await captureProcess('docker', ['inspect', '--format', '{{.State.Running}}', invocation.containerName]) : null;
+      const finished = stopped.code === 0 || absent?.stdout.trim() === 'false' || /No such (object|container)/i.test(absent?.stderr ?? '');
+      await recordResearchCleanup({ provider: 'docker', resource: invocation.containerName, status: finished ? 'released' : 'failed', ...(!finished ? { error: stopped.stderr.trim() } : {}) });
+      if (!finished) throw Error(`Could not stop container ${invocation.containerName}: ${stopped.stderr.trim()}`);
+    },
+  }).finally(() => stream?.end());
+
+  await recordRunnerProcessFinished({
+    executionDirectory: bundle.directories.execution,
+    startedEvent: runnerEvent,
+    exitCode: result.code,
+    signal: result.signal,
+    timedOut: result.timedOut,
+  });
+
+  await appendFile(
+    tracePath,
+    `${JSON.stringify({
+      type: "citeark.attempt_finished",
+      run_id: bundle.runId,
+      attempt,
+      exit_code: result.code,
+      signal: result.signal,
+      timed_out: result.timedOut,
+      recorded_at: new Date().toISOString(),
+    })}\n`,
+  );
+  return result;
+}
+
+export async function writeInvocation(bundle, invocations) {
+  const filename = path.join(bundle.directories.execution, 'invocation.json');
+  const previous = bundle.restored && await pathExists(filename) ? (await readJson(filename)).invocations : [];
+  const currentAttempts = new Set(invocations.map(item => item.attempt));
+  await writeJson(path.join(bundle.directories.execution, "invocation.json"), {
+    schemaVersion: "0.1",
+    sandbox: "docker",
+    credentials: {
+      agent: bundle.runtimeAgent.runtime,
+      protocol: bundle.runtimeAgent.api.protocol,
+      source: invocations[0]?.credentialRelay?.source ?? null,
+      mode: invocations[0]?.credentialRelay?.mode ?? "host-credential-relay",
+      injectedIntoSandbox:
+        invocations[0]?.credentialRelay?.injectedIntoSandbox ?? false,
+      valueRecorded: false,
+    },
+    networkEgress: invocations[0]?.networkEgress ?? { mode: "direct", allowedHosts: [] },
+    invocations: [...previous.filter(item => !currentAttempts.has(item.attempt)), ...invocations.map((invocation) => ({
+      attempt: invocation.attempt,
+      command: invocation.command,
+      args: sanitizeDockerArgs(invocation.args),
+      printable: invocation.printable,
+      containerName: invocation.containerName,
+    }))],
+  });
+}
+
+export async function dockerDoctor(image, runtime = "opencode") {
+  const client = await captureProcess("docker", ["--version"]).catch(() => null);
+  const server = await captureProcess("docker", ["version", "--format", "{{.Server.Version}}"]).catch(
+    () => null,
+  );
+  let imageInspection = null;
+  if (server?.code === 0 && image) {
+    imageInspection = await captureProcess("docker", [
+      "image",
+      "inspect",
+      "--format",
+      "{{.Id}}",
+      image,
+    ]).catch(() => null);
+  }
+  const runtimeCommand = runtime === "claude-code" ? "claude" : runtime;
+  const runtimeInspection = imageInspection?.code === 0
+    ? await captureProcess("docker", [
+        "run",
+        "--rm",
+        image,
+        runtimeCommand,
+        "--version",
+      ]).catch(() => null)
+    : null;
+  return {
+    client: client?.code === 0 ? client.stdout.trim() : null,
+    server: server?.code === 0 ? server.stdout.trim() : null,
+    image: imageInspection?.code === 0 ? imageInspection.stdout.trim() : null,
+    runtime: runtimeInspection?.code === 0
+      ? (runtimeInspection.stdout || runtimeInspection.stderr).trim()
+      : null,
+    issues: [
+      ...(client?.code === 0 ? [] : ["Docker CLI is unavailable"]),
+      ...(server?.code === 0 ? [] : ["Docker is not running or is inaccessible"]),
+      ...(server?.code === 0 && image && imageInspection?.code !== 0
+        ? [`Docker image not found: ${image}`]
+        : []),
+      ...(imageInspection?.code === 0 && runtimeInspection?.code !== 0
+        ? [`The image does not contain a working ${runtimeCommand} CLI`]
+        : []),
+    ],
+  };
+}
+
+export async function inspectDockerImage(image) {
+  const [id, repositoryDigests] = await Promise.all([
+    captureProcess("docker", ["image", "inspect", "--format", "{{.Id}}", image]).catch(
+      () => null,
+    ),
+    captureProcess("docker", [
+      "image",
+      "inspect",
+      "--format",
+      "{{json .RepoDigests}}",
+      image,
+    ]).catch(() => null),
+  ]);
+  if (id?.code !== 0) return null;
+  let parsedDigests = [];
+  if (repositoryDigests?.code === 0) {
+    try {
+      parsedDigests = JSON.parse(repositoryDigests.stdout.trim()) ?? [];
+    } catch {
+      parsedDigests = [];
+    }
+  }
+  return { id: id.stdout.trim(), repositoryDigests: parsedDigests };
+}
+
+export function requireRuntimeCredentials(agent) {
+  if (!agent.api?.apiKey) {
+    throw new CiteArkError("缺少本次运行的 API Key。真实密钥只保留在宿主机密钥隔离代理中。");
+  }
+}
+
+function providerDockerEnvironment(agent, providerSession) {
+  if (agent.runtime === "claude-code") {
+    return [
+      "--env",
+      `ANTHROPIC_API_KEY=${providerSession.containerCredential}`,
+      "--env",
+      `ANTHROPIC_BASE_URL=${providerSession.containerBaseUrl}`,
+      "--env",
+      `ANTHROPIC_MODEL=${agent.model}`,
+      "--env",
+      `ANTHROPIC_DEFAULT_OPUS_MODEL=${agent.model}`,
+      "--env",
+      `ANTHROPIC_DEFAULT_SONNET_MODEL=${agent.model}`,
+      "--env",
+      `ANTHROPIC_DEFAULT_HAIKU_MODEL=${agent.subagentModel}`,
+      "--env",
+      `CLAUDE_CODE_SUBAGENT_MODEL=${agent.subagentModel}`,
+      "--env",
+      `CLAUDE_CODE_EFFORT_LEVEL=${agent.effort}`,
+      "--env",
+      `CLAUDE_CODE_AUTO_COMPACT_WINDOW=${agent.autoCompactWindow}`,
+      "--env",
+      "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC=1",
+    ];
+  }
+  if (agent.runtime === "codex") {
+    return [
+      "--env",
+      `OPENAI_API_KEY=${providerSession.containerCredential}`,
+      "--env",
+      "CODEX_HOME=/job/runtime-home/codex",
+    ];
+  }
+  const config = {
+    $schema: "https://opencode.ai/config.json",
+    model: `citeark/${agent.model}`,
+    provider: {
+      citeark: {
+        npm: "@ai-sdk/openai-compatible",
+        name: "CiteArk Relay",
+        options: {
+          baseURL: `${providerSession.containerBaseUrl}/v1`,
+          apiKey: "{env:CITEARK_API_KEY}",
+        },
+        models: { [agent.model]: openCodeModelDefinition(agent) },
+      },
+    },
+  };
+  return [
+    "--env",
+    `CITEARK_API_KEY=${providerSession.containerCredential}`,
+    "--env",
+    `OPENCODE_CONFIG_CONTENT=${JSON.stringify(config)}`,
+    "--env",
+    "OPENCODE_DISABLE_AUTOUPDATE=1",
+  ];
+}
+
+function sanitizedHostRuntimeEnvironment() {
+  const environment = { ...process.env };
+  delete environment.ANTHROPIC_API_KEY;
+  delete environment.ANTHROPIC_AUTH_TOKEN;
+  delete environment.DEEPSEEK_API_KEY;
+  delete environment.OPENAI_API_KEY;
+  delete environment.CITEARK_API_KEY;
+  return environment;
+}
+
+function sanitizeDockerArgs(args) {
+  return args.map((argument) =>
+    argument
+      .replace(/^ANTHROPIC_AUTH_TOKEN=.*$/, "ANTHROPIC_AUTH_TOKEN=<redacted>")
+      .replace(/^ANTHROPIC_API_KEY=.*$/, "ANTHROPIC_API_KEY=<redacted>")
+      .replace(/^OPENAI_API_KEY=.*$/, "OPENAI_API_KEY=<redacted>")
+      .replace(/^CITEARK_API_KEY=.*$/, "CITEARK_API_KEY=<redacted>"),
+  );
+}
+
+// A crashed coordinator can leave Docker running. Never start a second Agent
+// against that same writable workspace when recovering its saved session.
+export async function assertLocalRunStopped(bundle, { run = captureProcess } = {}) {
+  if (!bundle.restored) return;
+  const filename = path.join(bundle.directories.execution, 'invocation.json');
+  if (!await pathExists(filename)) return;
+  const previous = (await readJson(filename)).invocations?.at(-1);
+  if (!previous?.containerName) return;
+  const result = await run('docker', ['inspect', '--format', '{{.State.Running}}', previous.containerName]);
+  if (result.code === 0 && result.stdout.trim() === 'true') throw new CiteArkError(`The previous container ${previous.containerName} is still running. Inspect it before stopping it or restarting this workspace.`);
+  if (result.code !== 0 && !/No such (object|container)/i.test(result.stderr)) throw new CiteArkError(`Cannot check the previous container: ${result.stderr.trim()}`);
+}

package/src/settings/command.mjs

@@ -0,0 +1,297 @@
+import {
+  readSettings,
+  writeSettings,
+  profileName,
+  modelProfile,
+  computeProfile,
+  resolveModelProfile,
+} from "./store.mjs";
+import { createTerminalPrompter } from "../deployment/terminal.mjs";
+import {
+  buildModelRequest,
+  readModelResponse,
+} from "../provider/completion.mjs";
+import { loadComputeCatalog, loadComputePolicy } from "../compute/catalog.mjs";
+
+export async function settingsCommand(
+  kind,
+  argv,
+  parseOptions,
+  prompt = process.stdin.isTTY ? createTerminalPrompter() : null,
+) {
+  const [action = "list", name, ...rest] = argv;
+  const settings = await readSettings();
+  const group = kind === "model" ? "models" : "compute";
+  const defaultKey = kind === "model" ? "defaultModel" : "defaultCompute";
+  if (action === "list") {
+    for (const [key, value] of Object.entries(settings[group]))
+      console.log(
+        `${key === settings[defaultKey] ? "*" : " "} ${key}  ${kind === "model" ? `${value.model} · ${value.apiBaseUrl}` : value.type === "ssh" ? value.host : value.type}`,
+      );
+    if (!Object.keys(settings[group]).length)
+      console.log(`No ${kind} profiles. Run citeark ${kind} add <name>.`);
+    return settings[group];
+  }
+  profileName(name);
+  if (["use", "remove", "check"].includes(action) && !settings[group][name])
+    throw Error(`Unknown ${kind} profile: ${name}`);
+  if (action === "use") settings[defaultKey] = name;
+  else if (action === "remove") {
+    delete settings[group][name];
+    if (settings[defaultKey] === name) delete settings[defaultKey];
+  } else if (action === "add") {
+    if (settings[group][name])
+      throw Error(
+        `Profile ${name} already exists. Remove it or use a new name.`,
+      );
+    if (kind === "model") {
+      const options = parseOptions(rest, {
+        "--agent": { type: "string" },
+        "--api-base-url": { type: "string" },
+        "--model": { type: "string" },
+        "--api-key-env": { type: "string" },
+        "--effort": { type: "string" },
+        "--budget": { type: "string" },
+      });
+      const runtime =
+        options["--agent"] ??
+        (prompt
+          ? await ask(prompt, "Agent runtime: opencode, codex or claude-code", {
+              defaultValue: "opencode",
+            })
+          : "opencode");
+      const apiBaseUrl =
+        options["--api-base-url"] ?? (await ask(prompt, "Model API base URL"));
+      const model = options["--model"] ?? (await ask(prompt, "Model name"));
+      const apiKeyEnv =
+        options["--api-key-env"] ??
+        (await ask(prompt, "API key environment variable", {
+          defaultValue: "CITEARK_MODEL_API_KEY",
+        }));
+      settings.models[name] = modelProfile({
+        runtime,
+        apiBaseUrl,
+        model,
+        ...(apiKeyEnv ? { apiKeyEnv } : {}),
+        ...(options["--effort"] ? { effort: options["--effort"] } : {}),
+        ...(options["--budget"]
+          ? { maxBudgetUsd: Number(options["--budget"]) }
+          : {}),
+      });
+    } else {
+      const options = parseOptions(rest, {
+        "--type": { type: "string" },
+        "--host": { type: "string" },
+        "--directory": { type: "string" },
+        "--port": { type: "string" },
+        "--identity": { type: "string" },
+        "--ssh-config": { type: "string" },
+        "--command": { type: "string" },
+        "--catalog": { type: "string" },
+        "--policy": { type: "string" },
+        "--profile": { type: "string" },
+        "--device": { type: "string" },
+        "--image": { type: "string" },
+      });
+      const type =
+        options["--type"] ??
+        (await ask(prompt, "Compute type: local, ssh or catalog", {
+          defaultValue: "local",
+        }));
+      settings.compute[name] = computeProfile({
+        type,
+        host:
+          options["--host"] ??
+          (type === "ssh"
+            ? await ask(prompt, "SSH host or config alias")
+            : undefined),
+        directory:
+          options["--directory"] ??
+          (type === "ssh"
+            ? await ask(prompt, "Remote workspace root (absolute path)")
+            : undefined),
+        ...(options["--port"] ? { port: Number(options["--port"]) } : {}),
+        identityFile: options["--identity"],
+        configFile: options["--ssh-config"],
+        command: options["--command"],
+        catalog:
+          options["--catalog"] ??
+          (type === "catalog"
+            ? await ask(prompt, "Compute catalog file")
+            : undefined),
+        policy: options["--policy"],
+        profile: options["--profile"],
+        device: options["--device"],
+        image: options["--image"],
+      });
+      if (type === "catalog") {
+        await loadComputeCatalog(settings.compute[name].catalog);
+        if (settings.compute[name].policy)
+          await loadComputePolicy(settings.compute[name].policy);
+      }
+    }
+    settings[defaultKey] ??= name;
+  } else if (action === "check") {
+    if (kind === "model") {
+      const value = resolveModelProfile(settings, name);
+      if (value.apiKeyEnv && !value.apiKey)
+        throw Error(`Set ${value.apiKeyEnv} before checking this model.`);
+      await checkModel(value);
+      console.log(
+        `Model ${name}: tool calling and structured response passed.`,
+      );
+    } else {
+      const value = settings.compute[name];
+      if (value.type === "ssh") {
+        const { sshCommand } = await import("../remote/ssh.mjs");
+        console.log(await sshCommand(value, ["doctor"]));
+      } else if (value.type === "catalog") {
+        await loadComputeCatalog(value.catalog);
+        console.log(
+          `Catalog ${name}: valid. Runtime credentials and capacity are checked when submitting a task.`,
+        );
+      } else {
+        const { checkLocalExecution } = await import(
+          "../deployment/environment.mjs"
+        );
+        console.log(
+          JSON.stringify(
+            await checkLocalExecution({
+              environment: {
+                image:
+                  value.image ??
+                  `citeark-agent/runtime:${value.device === "cuda" ? "cuda" : "cpu"}`,
+                gpu: value.device === "cuda" ? "all" : "none",
+                cpus: 1,
+                memoryGb: 1,
+              },
+              compute: {},
+            }),
+            null,
+            2,
+          ),
+        );
+      }
+    }
+    return;
+  } else throw Error(`Usage: citeark ${kind} list|add|use|remove|check [name]`);
+  await writeSettings(settings);
+  console.log(
+    `${kind === "model" ? "Model" : "Compute"} profile ${name}: ${action === "remove" ? "removed" : "saved"}.`,
+  );
+}
+async function ask(prompt, label, options) {
+  if (!prompt)
+    throw Error(
+      `${label} is required. Supply the matching command option or use an interactive terminal.`,
+    );
+  return prompt.ask(label, options);
+}
+
+export async function checkModel(agent, { fetchImpl = fetch } = {}) {
+  const messages = [
+    {
+      role: "user",
+      content:
+        'Call citeark_probe with value "ready", then return {"ready":true}.',
+    },
+  ];
+  const tools = [
+    {
+      type: "function",
+      function: {
+        name: "citeark_probe",
+        description: "Check tool response support.",
+        parameters: {
+          type: "object",
+          properties: { value: { type: "string" } },
+          required: ["value"],
+          additionalProperties: false,
+        },
+      },
+    },
+  ];
+  const format = {
+    type: "json_schema",
+    json_schema: {
+      name: "citeark_probe_result",
+      strict: true,
+      schema: {
+        type: "object",
+        properties: { ready: { type: "boolean" } },
+        required: ["ready"],
+        additionalProperties: false,
+      },
+    },
+  };
+  let called = false;
+  for (let turn = 0; turn < 3; turn++) {
+    const request = buildModelRequest({
+      agent,
+      apiKey: agent.apiKey,
+      messages,
+      tools,
+      format,
+      maxTokens: 4096,
+      signal: AbortSignal.timeout(60000),
+    });
+    const response = await fetchImpl(request.url, request.init);
+    if (!response.ok)
+      throw Error(
+        `Model check failed (HTTP ${response.status}). Check the endpoint, credentials and model capabilities.`,
+      );
+    const payload = readModelResponse(await response.json(), request.protocol);
+    const choice = payload.choices?.[0];
+    const message = choice?.message;
+    if (
+      payload.error ||
+      message?.refusal ||
+      (choice?.finish_reason &&
+        !["stop", "tool_calls"].includes(choice.finish_reason))
+    )
+      throw Error("Model response was refused or incomplete.");
+    if (!message) throw Error("Model returned no response.");
+    if (message.tool_calls?.length) {
+      messages.push({ ...message, role: "assistant" });
+      for (const call of message.tool_calls) {
+        if (
+          call.function.name !== "citeark_probe" ||
+          JSON.parse(call.function.arguments).value !== "ready"
+        )
+          throw Error("Model check returned an invalid tool call.");
+        called = true;
+        messages.push({
+          role: "tool",
+          tool_call_id: call.id,
+          content: '{"accepted":true}',
+        });
+      }
+    } else {
+      if (!called || JSON.parse(message.content).ready !== true)
+        throw Error(
+          "Model did not complete the tool and structured response check.",
+        );
+      return { protocol: request.protocol, model: agent.model };
+    }
+  }
+  throw Error("Model did not finish the connection check.");
+}
+
+export async function settingsMenu(kind, prompt) {
+  const settings = await readSettings();
+  const group = kind === "model" ? "models" : "compute";
+  const selected = await prompt.choose(`Select ${kind}`, [
+    ...Object.entries(settings[group]).map(([name, value]) => ({
+      value: name,
+      label: `${name} · ${value.model ?? value.host ?? value.type}`,
+    })),
+    { value: "+", label: "Add a profile" },
+  ]);
+  const { parseOptions } = await import("../cli.mjs");
+  if (selected === "+") {
+    const name = await prompt.ask("Profile name");
+    await settingsCommand(kind, ["add", name], parseOptions, prompt);
+    return settingsCommand(kind, ["use", name], parseOptions, prompt);
+  }
+  return settingsCommand(kind, ["use", selected], parseOptions, prompt);
+}