@toloka-platform/sdk 0.1.0-preview.7 → 0.1.0-preview.8

package/src/authoring/index.ts

@@ -51,7 +51,7 @@ export interface Connection {
   readonly settings: PipelineGraphV1["connections"][number]["settings"];
 }
 
-type FieldProxyReference = {
+type FieldReference = {
   readonly field: Field;
   readonly optional: boolean;
 };
@@ -124,26 +124,24 @@ type QuorumOutputEntity = FieldEntity<QuorumNodeSettings["entities"]["output"][n
 type QuorumQualityCriterion = FieldTarget<QuorumNodeSettings["qualityCriteria"][number]>;
 type QuorumExam = FieldExam<NonNullable<QuorumNodeSettings["exam"]>>;
 
-type MatchPredicate = Omit<
+type MatchPredicate = Pick<
   MatchNodeSettings["conditions"][number]["predicates"][number],
-  "fieldProxyId"
+  "jsonPath" | "operator" | "value"
 > & {
   readonly field: Field;
 };
 
-export type RootAuthoringSettings = Omit<
-  RootNodeSettings,
-  "datasetId" | "itemFilter" | "startedFieldProxies" | "completedFieldProxies"
-> & {
+export type RootAuthoringSettings = Pick<RootNodeSettings, "itemLimit"> & {
   readonly started: ReadonlyArray<RootFieldReference>;
   readonly completed: ReadonlyArray<RootFieldReference>;
 };
 
-export type CodeAuthoringSettings = Omit<CodeNodeSettings, "fieldProxies"> & {
-  readonly fieldProxies: {
-    readonly input: ReadonlyArray<FieldProxyReference>;
-    readonly output: ReadonlyArray<FieldProxyReference>;
-  };
+export type CodeAuthoringSettings = Pick<
+  CodeNodeSettings,
+  "about" | "code" | "envVars" | "checks"
+> & {
+  readonly input: ReadonlyArray<FieldReference>;
+  readonly output: ReadonlyArray<FieldReference>;
 };
 
 export type GenerationAuthoringSettings = Omit<
@@ -162,15 +160,13 @@ export type GenerationAuthoringSettings = Omit<
   readonly exam?: GenerationExam;
 };
 
-export type MatchAuthoringSettings = Omit<MatchNodeSettings, "conditions" | "fieldProxies"> & {
+export type MatchAuthoringSettings = Pick<MatchNodeSettings, "about"> & {
   readonly conditions: ReadonlyArray<
     Omit<MatchNodeSettings["conditions"][number], "predicates"> & {
       readonly predicates: ReadonlyArray<MatchPredicate>;
     }
   >;
-  readonly fieldProxies: {
-    readonly input: ReadonlyArray<FieldProxyReference>;
-  };
+  readonly input: ReadonlyArray<FieldReference>;
 };
 
 export type QuorumAuthoringSettings = Omit<
@@ -316,11 +312,14 @@ function referencedFields(value: unknown): ReadonlyArray<Field> {
   return references;
 }
 
-function compileFieldProxy(reference: FieldProxyReference): { id: string; optional: boolean } {
+function compileFieldReference(reference: FieldReference): { id: string; optional: boolean } {
   return { id: reference.field.id, optional: reference.optional };
 }
 
-function compileRootFieldProxy(reference: RootFieldReference): { id: string; optional: boolean } {
+function compileRootFieldReference(reference: RootFieldReference): {
+  id: string;
+  optional: boolean;
+} {
   return isField(reference)
     ? { id: reference.id, optional: false }
     : { id: reference.field.id, optional: reference.optional ?? false };
@@ -457,8 +456,8 @@ function createRoot(
     type: "root",
     settings: {
       ...settingsWithoutFieldProxies,
-      startedFieldProxies: { output: started.map(compileRootFieldProxy) },
-      completedFieldProxies: { input: completed.map(compileRootFieldProxy) },
+      startedFieldProxies: { output: started.map(compileRootFieldReference) },
+      completedFieldProxies: { input: completed.map(compileRootFieldReference) },
     },
     started: outputPort(id, "started"),
     completed: inputPort(id, "completed"),
@@ -477,14 +476,15 @@ export function code(
   options: AuthoringIdOptions = {},
 ): AuthoredCodeNode {
   const id = options.id ?? mintedId("code", name);
+  const { input, output, ...wireSettings } = settings;
   return {
     id,
     type: "code",
     settings: {
-      ...settings,
+      ...wireSettings,
       fieldProxies: {
-        input: settings.fieldProxies.input.map(compileFieldProxy),
-        output: settings.fieldProxies.output.map(compileFieldProxy),
+        input: input.map(compileFieldReference),
+        output: output.map(compileFieldReference),
       },
     },
     input: inputPort(id, "input"),
@@ -515,19 +515,20 @@ export function match(
   options: AuthoringIdOptions = {},
 ): AuthoredMatchNode {
   const id = options.id ?? mintedId("match", name);
+  const { conditions, input, ...wireSettings } = settings;
   return {
     id,
     type: "match",
     settings: {
-      ...settings,
-      conditions: settings.conditions.map((condition) => ({
+      ...wireSettings,
+      conditions: conditions.map((condition) => ({
         ...condition,
         predicates: condition.predicates.map(({ field: referencedField, ...predicate }) => ({
           ...predicate,
           fieldProxyId: referencedField.id,
         })),
       })),
-      fieldProxies: { input: settings.fieldProxies.input.map(compileFieldProxy) },
+      fieldProxies: { input: input.map(compileFieldReference) },
     },
     input: inputPort(id, "input"),
     default: outputPort(id, "default"),

package/src/cli/analytics.ts

@@ -7,6 +7,7 @@ import { PipelineGraphValidationError, PotatoApiError } from "../errors";
 import type { TolokaEnvironment } from "./config";
 import type { CliEnvironment } from "./credentials";
 import { credentialsPath, preparePrivateFilePath } from "./credentials";
+import { isFalseyFlag, isTruthyFlag } from "./boolean-flag";
 import { SDK_VERSION } from "./init";
 
 export const POSTHOG_PROJECT_KEY = "phc_kqHt0f53B5MVqURyzWpW1aNlbOmYt1YbUYza0JPcg19";
@@ -61,27 +62,13 @@ export type PosthogLike = {
   shutdown: (shutdownTimeoutMs?: number) => Promise<void>;
 };
 
-const isTruthy = (value: string | undefined): boolean => {
-  if (value === undefined) return false;
-  const normalized = value.trim().toLowerCase();
-  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
-};
-
-const isFalsey = (value: string | undefined): boolean => {
-  if (value === undefined) return false;
-  const normalized = value.trim().toLowerCase();
-  return (
-    normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off"
-  );
-};
-
 export function telemetryEnabled(environment: CliEnvironment): boolean {
   const explicit = environment.TOLOKA_TELEMETRY ?? process.env.TOLOKA_TELEMETRY;
-  if (isFalsey(explicit)) return false;
-  if (isTruthy(explicit)) return true;
-  if (isTruthy(environment.DO_NOT_TRACK ?? process.env.DO_NOT_TRACK)) return false;
-  if (isTruthy(environment.CI ?? process.env.CI)) return false;
-  if (isTruthy(process.env.VITEST)) return false;
+  if (isFalseyFlag(explicit)) return false;
+  if (isTruthyFlag(explicit)) return true;
+  if (isTruthyFlag(environment.DO_NOT_TRACK ?? process.env.DO_NOT_TRACK)) return false;
+  if (isTruthyFlag(environment.CI ?? process.env.CI)) return false;
+  if (isTruthyFlag(process.env.VITEST)) return false;
   return true;
 }
 
@@ -99,12 +86,14 @@ const COMMAND_GROUPS: Readonly<Record<string, Readonly<Record<string, true>>>> =
   dataset: { list: true, fields: true, load: true, upload: true },
   secret: { set: true },
   skill: { list: true, search: true, install: true },
+  config: { get: true, set: true },
 };
 
 const ROOT_COMMANDS: Readonly<Record<string, true>> = {
   apply: true,
   check: true,
   "auth-status": true,
+  config: true,
   help: true,
   import: true,
   init: true,

package/src/cli/auto-update.ts

@@ -0,0 +1,367 @@
+import { spawn } from "node:child_process";
+import { once } from "node:events";
+import { realpathSync } from "node:fs";
+import { chmod, readFile, writeFile } from "node:fs/promises";
+import { join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import type { CliEnvironment } from "./credentials";
+import { configDirectory, preparePrivateFilePath } from "./credentials";
+import { SDK_VERSION } from "./init";
+import { commandNameFromArgv } from "./analytics";
+import { readCliSettings } from "./settings";
+import { CHECK_RESULT_FILE_ENV } from "./check";
+import { isFalseyFlag, isTruthyFlag } from "./boolean-flag";
+import packageMetadata from "../../package.json" with { type: "json" };
+
+export const AUTO_UPDATE_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export const AUTO_UPDATE_QUARANTINE_MS = 24 * 60 * 60 * 1000;
+export const SDK_PACKAGE_NAME = packageMetadata.name;
+export const DEFAULT_NPM_REGISTRY = "https://registry.npmjs.org/";
+
+const SKIP_COMMANDS: Readonly<Record<string, true>> = {
+  config: true,
+  help: true,
+  version: true,
+};
+
+export type AutoUpdateState = {
+  readonly lastCheckedAt: string;
+};
+
+export type NpmPackageView = {
+  readonly "dist-tags"?: Readonly<Record<string, string>>;
+  readonly time?: Readonly<Record<string, string>>;
+};
+
+export type AutoUpdateInstall = (options: {
+  readonly packageName: string;
+  readonly version: string;
+  readonly registry: string;
+  readonly environment: CliEnvironment;
+}) => Promise<void>;
+
+export type AutoUpdateReexec = (options: {
+  readonly argv: readonly string[];
+  readonly environment: CliEnvironment;
+}) => Promise<number>;
+
+export type AutoUpdateHooks = {
+  readonly now?: () => Date;
+  readonly fetchRegistry?: (url: string) => Promise<NpmPackageView>;
+  readonly install?: AutoUpdateInstall;
+  readonly reexec?: AutoUpdateReexec;
+  readonly isGlobalInstall?: () => boolean | Promise<boolean>;
+};
+
+export type AutoUpdateResult =
+  | { readonly status: "continue" }
+  | { readonly status: "reexec"; readonly exitCode: number };
+
+type CliIoWriter = {
+  readonly stderr: (text: string) => void;
+};
+
+type UpdateCheck = { readonly status: "skip" } | { readonly status: "check"; readonly now: Date };
+
+type UpdateCandidate =
+  | { readonly status: "skip" }
+  | { readonly status: "update"; readonly currentVersion: string; readonly version: string };
+
+export const autoUpdateStatePath = (environment: CliEnvironment = process.env): string =>
+  join(configDirectory(environment), "auto-update.json");
+
+export const npmRegistryUrl = (): string => DEFAULT_NPM_REGISTRY;
+
+export const npmPackageMetadataUrl = (packageName: string): string =>
+  new URL(encodeURIComponent(packageName), DEFAULT_NPM_REGISTRY).toString();
+
+export const parseSdkVersion = (version: string): readonly number[] | undefined => {
+  const match = /^(\d+)\.(\d+)\.(\d+)(?:-preview\.(\d+))?$/u.exec(version);
+  if (match === null) return undefined;
+  const [, major, minor, patch, preview] = match;
+  return [
+    Number(major),
+    Number(minor),
+    Number(patch),
+    preview === undefined ? Number.POSITIVE_INFINITY : Number(preview),
+  ];
+};
+
+export const compareSdkVersions = (left: string, right: string): number | undefined => {
+  const parsedLeft = parseSdkVersion(left);
+  const parsedRight = parseSdkVersion(right);
+  if (parsedLeft === undefined || parsedRight === undefined) return undefined;
+  const length = Math.max(parsedLeft.length, parsedRight.length);
+  for (let index = 0; index < length; index += 1) {
+    const leftPart = parsedLeft[index] ?? 0;
+    const rightPart = parsedRight[index] ?? 0;
+    if (leftPart < rightPart) return -1;
+    if (leftPart > rightPart) return 1;
+  }
+  return 0;
+};
+
+const asStringRecord = (value: unknown): Readonly<Record<string, string>> | undefined => {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return undefined;
+  const record: Record<string, string> = {};
+  for (const [key, entry] of Object.entries(value)) {
+    if (typeof entry !== "string") return undefined;
+    record[key] = entry;
+  }
+  return record;
+};
+
+export const asNpmPackageView = (payload: unknown): NpmPackageView | undefined => {
+  if (typeof payload !== "object" || payload === null) return undefined;
+  const tags = asStringRecord(Reflect.get(payload, "dist-tags"));
+  const time = asStringRecord(Reflect.get(payload, "time"));
+  if (tags === undefined && time === undefined) return {};
+  return {
+    ...(tags === undefined ? {} : { "dist-tags": tags }),
+    ...(time === undefined ? {} : { time }),
+  };
+};
+
+export const latestPublishedVersion = (view: NpmPackageView): string | undefined => {
+  const tags = view["dist-tags"];
+  if (tags === undefined) return undefined;
+  const preview = tags.preview;
+  if (typeof preview === "string" && preview.length > 0) return preview;
+  const latest = tags.latest;
+  return typeof latest === "string" && latest.length > 0 ? latest : undefined;
+};
+
+const publishedAt = (view: NpmPackageView, version: string): Date | undefined => {
+  const raw = view.time?.[version];
+  if (typeof raw !== "string" || raw.length === 0) return undefined;
+  const date = new Date(raw);
+  return Number.isNaN(date.getTime()) ? undefined : date;
+};
+
+const asState = (payload: unknown): AutoUpdateState | undefined => {
+  if (typeof payload !== "object" || payload === null) return undefined;
+  const lastCheckedAt = Reflect.get(payload, "lastCheckedAt");
+  if (typeof lastCheckedAt !== "string" || lastCheckedAt.length === 0) return undefined;
+  const date = new Date(lastCheckedAt);
+  if (Number.isNaN(date.getTime())) return undefined;
+  return { lastCheckedAt };
+};
+
+export async function readAutoUpdateState(
+  environment: CliEnvironment = process.env,
+): Promise<AutoUpdateState | undefined> {
+  try {
+    return asState(JSON.parse(await readFile(autoUpdateStatePath(environment), "utf8")));
+  } catch {
+    return undefined;
+  }
+}
+
+export async function writeAutoUpdateState(
+  state: AutoUpdateState,
+  environment: CliEnvironment = process.env,
+): Promise<string> {
+  const path = autoUpdateStatePath(environment);
+  await preparePrivateFilePath(path);
+  await writeFile(path, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
+  await chmod(path, 0o600);
+  return path;
+}
+
+const BUN_GLOBAL_MARKER = `${sep}install${sep}global${sep}`;
+
+export const isGlobalCliInstall = (
+  entry = process.argv[1],
+  runtimePath = fileURLToPath(import.meta.url),
+): boolean =>
+  [entry, runtimePath].some((path) => {
+    if (typeof path !== "string") return false;
+    try {
+      return realpathSync(path).includes(BUN_GLOBAL_MARKER);
+    } catch {
+      return path.includes(BUN_GLOBAL_MARKER);
+    }
+  });
+
+export function autoUpdateEnabled(
+  environment: CliEnvironment,
+  settings: { readonly autoUpdate: boolean },
+): boolean {
+  if (isTruthyFlag(environment.TOLOKA_SKIP_AUTO_UPDATE)) return false;
+  const explicit = environment.TOLOKA_AUTO_UPDATE;
+  if (isFalseyFlag(explicit)) return false;
+  if (isTruthyFlag(explicit)) return true;
+  if (environment[CHECK_RESULT_FILE_ENV] !== undefined) return false;
+  if (isTruthyFlag(environment.CI)) return false;
+  if (isTruthyFlag(environment.VITEST)) return false;
+  return settings.autoUpdate;
+}
+
+const skippedCommand = (argv: readonly string[]): boolean => {
+  const command = commandNameFromArgv(argv);
+  return SKIP_COMMANDS[command] === true || command.startsWith("config ");
+};
+
+const collectOutput = async (stream: NodeJS.ReadableStream | null): Promise<string> => {
+  if (stream === null) return "";
+  const chunks: Buffer[] = [];
+  stream.on("data", (chunk: Buffer | string) => {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  });
+  await once(stream, "end").catch(() => undefined);
+  return Buffer.concat(chunks).toString("utf8");
+};
+
+class RegistryError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "RegistryError";
+  }
+}
+
+const defaultFetchRegistry = async (url: string): Promise<NpmPackageView> => {
+  const response = await fetch(url, {
+    headers: { accept: "application/json" },
+    signal: AbortSignal.timeout(3000),
+  });
+  if (!response.ok) throw new RegistryError(`npm registry responded ${response.status}`);
+  const view = asNpmPackageView(await response.json());
+  if (view === undefined) throw new RegistryError("npm registry returned invalid package metadata");
+  return view;
+};
+
+const defaultInstall: AutoUpdateInstall = async ({
+  packageName,
+  version,
+  registry,
+  environment,
+}) => {
+  const child = spawn(
+    process.execPath,
+    ["add", "--global", `${packageName}@${version}`, `--registry=${registry}`],
+    {
+      env: { ...process.env, ...environment },
+      stdio: ["ignore", "pipe", "pipe"],
+    },
+  );
+  const [close, stdout, stderr] = await Promise.all([
+    once(child, "close"),
+    collectOutput(child.stdout),
+    collectOutput(child.stderr),
+  ]);
+  const exitCode = close[0];
+  if (exitCode === 0) return;
+  const detail = [stderr.trim(), stdout.trim()].filter((part) => part.length > 0).join("\n");
+  throw new Error(
+    detail.length > 0
+      ? `bun add --global failed: ${detail}`
+      : `bun add --global exited ${String(exitCode)}`,
+  );
+};
+
+const defaultReexec: AutoUpdateReexec = async ({ argv, environment }) => {
+  const entry = process.argv[1];
+  const child = spawn(process.execPath, entry === undefined ? [...argv] : [entry, ...argv], {
+    env: { ...process.env, ...environment, TOLOKA_SKIP_AUTO_UPDATE: "1" },
+    stdio: "inherit",
+  });
+  const [code] = await once(child, "close");
+  return typeof code === "number" ? code : 1;
+};
+
+const continueResult = (): AutoUpdateResult => ({ status: "continue" });
+
+const shouldCheckForUpdate = async (options: {
+  readonly argv: readonly string[];
+  readonly environment: CliEnvironment;
+  readonly hooks: AutoUpdateHooks;
+}): Promise<UpdateCheck> => {
+  const { argv, environment, hooks } = options;
+  if (skippedCommand(argv)) return { status: "skip" };
+  const isGlobal = hooks.isGlobalInstall ?? (() => isGlobalCliInstall());
+  if (!(await isGlobal())) return { status: "skip" };
+  const settings = await readCliSettings(environment);
+  if (!autoUpdateEnabled(environment, settings)) return { status: "skip" };
+
+  const now = hooks.now?.() ?? new Date();
+  const state = await readAutoUpdateState(environment);
+  if (state !== undefined) {
+    const lastCheckedAt = new Date(state.lastCheckedAt).getTime();
+    if (now.getTime() - lastCheckedAt < AUTO_UPDATE_INTERVAL_MS) return { status: "skip" };
+  }
+  return { status: "check", now };
+};
+
+const selectUpdateCandidate = async (options: {
+  readonly environment: CliEnvironment;
+  readonly io: CliIoWriter;
+  readonly now: Date;
+  readonly currentVersion: string;
+  readonly fetchRegistry: (url: string) => Promise<NpmPackageView>;
+}): Promise<UpdateCandidate> => {
+  const { environment, io, now, currentVersion, fetchRegistry } = options;
+  try {
+    await writeAutoUpdateState({ lastCheckedAt: now.toISOString() }, environment);
+  } catch {}
+
+  let view: NpmPackageView;
+  try {
+    view = await fetchRegistry(npmPackageMetadataUrl(SDK_PACKAGE_NAME));
+  } catch (error) {
+    io.stderr(
+      `Auto-update check failed: ${error instanceof Error ? error.message : String(error)}.`,
+    );
+    return { status: "skip" };
+  }
+
+  const version = latestPublishedVersion(view);
+  if (version === undefined) return { status: "skip" };
+  const order = compareSdkVersions(currentVersion, version);
+  if (order === undefined || order >= 0) return { status: "skip" };
+  const published = publishedAt(view, version);
+  if (published === undefined) return { status: "skip" };
+  if (now.getTime() - published.getTime() < AUTO_UPDATE_QUARANTINE_MS) return { status: "skip" };
+  return { status: "update", currentVersion, version };
+};
+
+export async function maybeAutoUpdate(options: {
+  readonly argv: readonly string[];
+  readonly environment: CliEnvironment;
+  readonly io: CliIoWriter;
+  readonly currentVersion?: string;
+  readonly hooks?: AutoUpdateHooks;
+}): Promise<AutoUpdateResult> {
+  const { argv, environment, io, hooks = {} } = options;
+  const check = await shouldCheckForUpdate({ argv, environment, hooks });
+  if (check.status === "skip") return continueResult();
+
+  const candidate = await selectUpdateCandidate({
+    environment,
+    io,
+    now: check.now,
+    currentVersion: options.currentVersion ?? SDK_VERSION,
+    fetchRegistry: hooks.fetchRegistry ?? defaultFetchRegistry,
+  });
+  if (candidate.status === "skip") return continueResult();
+
+  const install = hooks.install ?? defaultInstall;
+  try {
+    await install({
+      packageName: SDK_PACKAGE_NAME,
+      version: candidate.version,
+      registry: npmRegistryUrl(),
+      environment,
+    });
+  } catch (error) {
+    io.stderr(
+      `Auto-update to ${candidate.version} failed: ${error instanceof Error ? error.message : String(error)}.`,
+    );
+    return continueResult();
+  }
+
+  io.stderr(
+    `Updated ${SDK_PACKAGE_NAME} from ${candidate.currentVersion} to ${candidate.version}.`,
+  );
+  const reexec = hooks.reexec ?? defaultReexec;
+  return { status: "reexec", exitCode: await reexec({ argv, environment }) };
+}

package/src/cli/boolean-flag.ts

@@ -0,0 +1,13 @@
+export const isTruthyFlag = (value: string | undefined): boolean => {
+  if (value === undefined) return false;
+  const normalized = value.trim().toLowerCase();
+  return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+};
+
+export const isFalseyFlag = (value: string | undefined): boolean => {
+  if (value === undefined) return false;
+  const normalized = value.trim().toLowerCase();
+  return (
+    normalized === "0" || normalized === "false" || normalized === "no" || normalized === "off"
+  );
+};

package/src/cli/credentials.ts

@@ -52,6 +52,9 @@ export const credentialsPath = (environment: CliEnvironment = process.env): stri
 export const legacyCredentialsPath = (environment: CliEnvironment = process.env): string =>
   join(home(environment), ".toloka", "credentials.json");
 
+export const configDirectory = (environment: CliEnvironment = process.env): string =>
+  dirname(credentialsPath(environment));
+
 const removeTrailingSlashes = (value: string): string => {
   let end = value.length;
   while (end > 0 && value.charCodeAt(end - 1) === 47) end -= 1;

package/src/cli/program.ts

@@ -19,6 +19,8 @@ import { authStatus, login, logout } from "./auth";
 import type { AuthPrompt } from "./auth";
 import { commandNameFromArgv, createCliAnalytics } from "./analytics";
 import type { CliAnalytics, CliAnalyticsCommandOutcome } from "./analytics";
+import type { AutoUpdateHooks } from "./auto-update";
+import { maybeAutoUpdate } from "./auto-update";
 import { PRODUCTION_BASE_URL, resolveInternalBaseUrl, resolveTolokaConfig } from "./config";
 import type { TolokaEnvironment } from "./config";
 import {
@@ -27,6 +29,7 @@ import {
   requireStoredCredentials,
 } from "./credentials";
 import type { StoredCredentials } from "./credentials";
+import { getCliSetting, readCliSettings, setCliSetting } from "./settings";
 import {
   generateDatasetFieldDeclarations,
   listProjectDatasets,
@@ -269,7 +272,8 @@ export function createProgram(context: ProgramContext): CreatedProgram {
       commandNames.includes("help") ||
       commandNames.includes("report") ||
       commandNames.includes("url") ||
-      commandNames.includes("version")
+      commandNames.includes("version") ||
+      commandNames.includes("config")
     )
       return;
     const sourceRoot = await resolveSourceRoot(globals(), context.io);
@@ -283,6 +287,29 @@ export function createProgram(context: ProgramContext): CreatedProgram {
     .description("print the current CLI version")
     .action(() => context.io.stdout(SDK_VERSION));
 
+  const config = program.command("config").description("read and write machine CLI settings");
+  config
+    .command("get")
+    .argument("[name]", "setting name; omit to print every setting")
+    .description("print a CLI setting, or every setting")
+    .action(async (name?: string) => {
+      const settings = await readCliSettings(context.environment);
+      context.io.stdout(getCliSetting(settings, name).output);
+    });
+  config
+    .command("set")
+    .argument("<name>", "setting name")
+    .argument("<value>", "setting value")
+    .description("write a CLI setting for this machine")
+    .action(async (name: string, value: string) => {
+      const result = await setCliSetting(context.environment, name, value);
+      context.io.stdout(result.output);
+    });
+  config.action(async () => {
+    const settings = await readCliSettings(context.environment);
+    context.io.stdout(getCliSetting(settings, undefined).output);
+  });
+
   program
     .command("login")
     .description("store an API key for this machine after verifying it")
@@ -1127,7 +1154,16 @@ export async function runTolokaCli(
   injectedClient?: PotatoClient,
   analytics?: CliAnalytics,
   runChecks?: typeof checkProject,
+  autoUpdate?: AutoUpdateHooks,
 ): Promise<number> {
+  const autoUpdateResult = await maybeAutoUpdate({
+    argv,
+    environment,
+    io,
+    ...(autoUpdate === undefined ? {} : { hooks: autoUpdate }),
+  });
+  if (autoUpdateResult.status === "reexec") return autoUpdateResult.exitCode;
+
   const activeAnalytics =
     environment[CHECK_RESULT_FILE_ENV] === undefined
       ? (analytics ?? createCliAnalytics({ environment }))