iit-mcp-autotask 0.11.0 → 0.11.2

package/README.md

@@ -155,7 +155,13 @@ What the policy can and cannot do:
   original (the vendor ignores an update of `ticketID`): the new record gets a new id, create date and
   creator, and notifications may fire. A move into another company or contract always needs a signed
   approval grant; an unfinished earlier move of the same source blocks another until its ledger entry ages
-  out (14 days). Billed, attached, approved, closed-target and older-than-14-days sources are refused.
+  out (14 days) or a person clears it: in a terminal, as the server's OS user, with `AUTOTASK_STATE_DIR` set,
+  `autotask-mcp moves list` shows the blocked sources and `autotask-mcp moves resolve <resource>:<id>` (after you
+  checked both tickets in Autotask; you type the source id, and the copy's id when the ledger names one) closes the
+  ledger lines as `MOVE_RESOLVED` and audits it (`move_resolved`). It refuses within 10 minutes of the move being sent
+  (its engine may still be running) and, while the engine may still run, when the sending server is still registered or alive. A plan previewed
+  before the resolve cannot apply after it. It is not an
+  MCP tool; like the approvals CLI it is a guardrail, not a boundary against an agent with a same-user shell. Billed, attached, approved, closed-target and older-than-14-days sources are refused.
 - Hard rules no policy overrides: `authenticate.*` is never served; operations the SDK flags
   `requiresApproval`, and non-read sensitive ones (webhooks, `resources.transferOwnership`), always
   need approval; destructive and account-wide operations need it, and `allowUnattended` cannot waive

package/dist/config/constants.d.ts

@@ -0,0 +1,24 @@
+/** The closed value sets of the configuration: transports, profiles, toolsets, cache presets and the removed variables (issue #91). */
+/** `stdio` = local path (Claude Code / Claude Desktop / VS Code); `http` = remote (gateway). */
+export declare const TRANSPORTS: readonly ["stdio", "http"];
+export type Transport = (typeof TRANSPORTS)[number];
+/**
+ * The deployment profile (0.6.0). `readonly` (the default) serves reads only and holds no state;
+ * `operator` adds the preview/apply write path (`autotask_write`, `autotask_apply`), which needs a
+ * policy file, a state dir and a run scope (see `src/write/runtime.ts`).
+ */
+export declare const PROFILES: readonly ["readonly", "operator"];
+export type Profile = (typeof PROFILES)[number];
+/** The optional toolsets `AUTOTASK_TOOLSETS` selects; `core` is always registered. */
+export declare const TOOLSETS: readonly ["service", "records", "finance"];
+export type Toolset = (typeof TOOLSETS)[number];
+/**
+ * The 0.5.x variables 0.6.0 removed, with the replacement each boot refusal names. Boot fails when
+ * any is set: a deployment that still sets one expects a behaviour this build no longer has.
+ */
+export declare const REMOVED_VARIABLES: Readonly<Record<string, string>>;
+/** The per-tenant read-cache preset every client this server builds gets. */
+export declare const CACHE_PRESETS: readonly ["on", "off"];
+export type CachePreset = (typeof CACHE_PRESETS)[number];
+/** The vendor's hard cap on requests per hour per integration (the local limiter must not exceed it). */
+export declare const VENDOR_HOURLY_CAP = 10000;

package/dist/config/constants.js

@@ -0,0 +1,26 @@
+/** The closed value sets of the configuration: transports, profiles, toolsets, cache presets and the removed variables (issue #91). */
+/** `stdio` = local path (Claude Code / Claude Desktop / VS Code); `http` = remote (gateway). */
+export const TRANSPORTS = ['stdio', 'http'];
+/**
+ * The deployment profile (0.6.0). `readonly` (the default) serves reads only and holds no state;
+ * `operator` adds the preview/apply write path (`autotask_write`, `autotask_apply`), which needs a
+ * policy file, a state dir and a run scope (see `src/write/runtime.ts`).
+ */
+export const PROFILES = ['readonly', 'operator'];
+/** The optional toolsets `AUTOTASK_TOOLSETS` selects; `core` is always registered. */
+export const TOOLSETS = ['service', 'records', 'finance'];
+/**
+ * The 0.5.x variables 0.6.0 removed, with the replacement each boot refusal names. Boot fails when
+ * any is set: a deployment that still sets one expects a behaviour this build no longer has.
+ */
+export const REMOVED_VARIABLES = {
+    AUTOTASK_READ_ONLY: 'AUTOTASK_PROFILE=readonly (the default) or AUTOTASK_PROFILE=operator',
+    AUTOTASK_WRITE_POLICY: 'AUTOTASK_PROFILE=readonly (the default) or AUTOTASK_PROFILE=operator',
+    AUTOTASK_WRITE_ALLOW: 'AUTOTASK_PROFILE=operator (writes are governed by the operator write path)',
+    AUTOTASK_SECRET_READS: 'nothing: authenticate.* is always refused (credential-minting)',
+};
+/** The per-tenant read-cache preset every client this server builds gets. */
+export const CACHE_PRESETS = ['on', 'off'];
+/** The vendor's hard cap on requests per hour per integration (the local limiter must not exceed it). */
+export const VENDOR_HOURLY_CAP = 10_000;
+//# sourceMappingURL=constants.js.map

package/dist/config/credentials.d.ts

@@ -0,0 +1,36 @@
+import { type Config } from './schema.js';
+/** The recognised AUTOTASK_* names: the config schema's AUTOTASK_ keys + the removed 0.5.x set (derived, never hand-listed). */
+export declare function recognisedAutotaskVars(): string[];
+/** The set-but-unrecognised AUTOTASK_* env keys (stale 0.4.x-era vars the server never reads). */
+export declare function unrecognisedAutotaskVars(env: Record<string, string | undefined>): string[];
+/**
+ * Load the three server-held credential values through the SDK's canonical loader
+ * (`loadAutotaskCredentialsFromEnv`, node-autotask 0.8.0), so this process has exactly ONE parser
+ * for them: the shell-equivalent one that strips a surrounding quote pair, drops a CRLF's `\r` and
+ * trims edge whitespace — the same rules `set -a; . ./.env; set +a` applies. The deprecated aliases
+ * (`AUTOTASK_API_CODE`, `AUTOTASK_API_INTEGRATION_CODE`, `AUTOTASK_USER`) are read as fall-backs.
+ *
+ * Returns only the value-free facts: which names were seen, their shapes, and the SDK's own typed
+ * failure when the loader refused one (the SDK's `INVALID_CREDENTIAL_SHAPE` — surfaced as this
+ * server's typed `CREDENTIAL_MALFORMED` refusal, never re-implemented).
+ */
+export interface ServerCredentialIntake {
+    /** The SDK's own verdict: the shape problem it named, or undefined for a loadable set. */
+    readonly sdkProblem?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+export declare function loadServerCredentials(env: Record<string, string | undefined>): ServerCredentialIntake;
+/**
+ * The server-held credential defaults as a set (or `undefined` when any member is unset — the
+ * tuple is all-or-nothing on the config surface; see the module docblock for why).
+ */
+export declare function serverCredentialDefaults(config: Config): {
+    apiIntegrationCode: string;
+    userName: string;
+    secret: string;
+    impersonationResourceId?: string;
+} | undefined;
+/** True when a full server-held credential tuple is present (the discouraged `http` default). */
+export declare function hasServerCredentialDefaults(config: Config): boolean;

package/dist/config/credentials.js

@@ -0,0 +1,79 @@
+/** Server credential intake and defaults: recognised variables, the credential load, the stdio defaults (issue #91). */
+import { loadAutotaskCredentialsFromEnv } from 'node-autotask';
+import { REMOVED_VARIABLES } from './constants.js';
+import { CONFIG_FIELDS } from './schema.js';
+/** The recognised AUTOTASK_* names: the config schema's AUTOTASK_ keys + the removed 0.5.x set (derived, never hand-listed). */
+export function recognisedAutotaskVars() {
+    const schemaKeys = Object.keys(CONFIG_FIELDS.shape).filter((k) => k.startsWith('AUTOTASK_'));
+    return [...new Set([...schemaKeys, ...Object.keys(REMOVED_VARIABLES)])].sort();
+}
+/** The set-but-unrecognised AUTOTASK_* env keys (stale 0.4.x-era vars the server never reads). */
+export function unrecognisedAutotaskVars(env) {
+    const recognised = new Set(recognisedAutotaskVars());
+    return Object.keys(env).filter((k) => k.startsWith('AUTOTASK_') && !recognised.has(k)).sort();
+}
+export function loadServerCredentials(env) {
+    // Only the PRODUCTION spellings are consulted: `loadAutotaskCredentialsFromEnv` also reads the
+    // deprecated aliases (`AUTOTASK_API_CODE` / `AUTOTASK_API_INTEGRATION_CODE`, `AUTOTASK_USER`), so
+    // it is called on a projection that carries exactly the variables this server documents. Without
+    // that, an http deployment with no server-held tuple at all would be told the SDK's loader
+    // "refused" a credential that this server never reads.
+    const canonical = {
+        AUTOTASK_TRACKING_IDENTIFIER: env.AUTOTASK_API_INTEGRATION_CODE,
+        AUTOTASK_USERNAME: env.AUTOTASK_USERNAME,
+        AUTOTASK_SECRET: env.AUTOTASK_SECRET,
+        AUTOTASK_IMPERSONATION_ID: env.AUTOTASK_IMPERSONATION_RESOURCE_ID,
+    };
+    const present = Object.values(canonical).filter((v) => v !== undefined && v.trim() !== '').length;
+    if (present === 0)
+        return {};
+    // A PARTIAL server-held tuple is the documented all-or-nothing case (`serverCredentialDefaults`
+    // returns undefined and the tuple is simply not served) — not a load refusal. The SDK's loader
+    // exists to load a COMPLETE credential set, so it is asked only when all three are present; a
+    // partial one is judged by the shape check above, field by field.
+    if (canonical.AUTOTASK_TRACKING_IDENTIFIER === undefined ||
+        canonical.AUTOTASK_TRACKING_IDENTIFIER.trim() === '' ||
+        canonical.AUTOTASK_USERNAME === undefined ||
+        canonical.AUTOTASK_USERNAME.trim() === '' ||
+        canonical.AUTOTASK_SECRET === undefined ||
+        canonical.AUTOTASK_SECRET.trim() === '') {
+        return {};
+    }
+    try {
+        loadAutotaskCredentialsFromEnv(canonical);
+        return {};
+    }
+    catch (err) {
+        const e = err;
+        return {
+            sdkProblem: {
+                code: typeof e.code === 'string' ? e.code : 'CONFIG_ERROR',
+                message: typeof e.message === 'string' ? e.message : 'the credential values could not be loaded',
+            },
+        };
+    }
+}
+/**
+ * The server-held credential defaults as a set (or `undefined` when any member is unset — the
+ * tuple is all-or-nothing on the config surface; see the module docblock for why).
+ */
+export function serverCredentialDefaults(config) {
+    if (config.AUTOTASK_API_INTEGRATION_CODE === undefined ||
+        config.AUTOTASK_USERNAME === undefined ||
+        config.AUTOTASK_SECRET === undefined) {
+        return undefined;
+    }
+    return {
+        apiIntegrationCode: config.AUTOTASK_API_INTEGRATION_CODE,
+        userName: config.AUTOTASK_USERNAME,
+        secret: config.AUTOTASK_SECRET,
+        ...(config.AUTOTASK_IMPERSONATION_RESOURCE_ID !== undefined
+            ? { impersonationResourceId: config.AUTOTASK_IMPERSONATION_RESOURCE_ID }
+            : {}),
+    };
+}
+/** True when a full server-held credential tuple is present (the discouraged `http` default). */
+export function hasServerCredentialDefaults(config) {
+    return serverCredentialDefaults(config) !== undefined;
+}
+//# sourceMappingURL=credentials.js.map

package/dist/config/error.d.ts

@@ -0,0 +1,5 @@
+/** The configuration error every boot refusal throws (issue #91). */
+/** Thrown only by {@link loadConfig}. Never carries a credential value — only variable names. */
+export declare class ConfigError extends Error {
+    readonly name = "ConfigError";
+}

package/dist/config/error.js

@@ -0,0 +1,6 @@
+/** The configuration error every boot refusal throws (issue #91). */
+/** Thrown only by {@link loadConfig}. Never carries a credential value — only variable names. */
+export class ConfigError extends Error {
+    name = 'ConfigError';
+}
+//# sourceMappingURL=error.js.map

package/dist/config/load.d.ts

@@ -0,0 +1,12 @@
+import { type Config } from './schema.js';
+/**
+ * Parse and validate configuration from an environment-shaped record.
+ *
+ * Takes the environment as an argument (main.ts merges the CLI's operational overrides into it)
+ * rather than reading `process.env` directly, so the failure paths are testable without mutating
+ * global state.
+ *
+ * @throws {ConfigError} when any variable is missing or malformed. The message lists every
+ *   problem at once — a boot loop that surfaces one missing variable per restart wastes real minutes.
+ */
+export declare function loadConfig(env?: Record<string, string | undefined>): Config;

package/dist/config/load.js

@@ -0,0 +1,70 @@
+/** `loadConfig`: the environment in, a validated Config out (issue #91). */
+import { MALFORMED_CREDENTIAL_REFUSAL, detectCredentialShape, malformedCredentialBootMessage } from '../credential.js';
+import { REMOVED_VARIABLES } from './constants.js';
+import { CONFIG_FIELDS, schema } from './schema.js';
+import { unrecognisedAutotaskVars, loadServerCredentials } from './credentials.js';
+import { ConfigError } from './error.js';
+/**
+ * Parse and validate configuration from an environment-shaped record.
+ *
+ * Takes the environment as an argument (main.ts merges the CLI's operational overrides into it)
+ * rather than reading `process.env` directly, so the failure paths are testable without mutating
+ * global state.
+ *
+ * @throws {ConfigError} when any variable is missing or malformed. The message lists every
+ *   problem at once — a boot loop that surfaces one missing variable per restart wastes real minutes.
+ */
+export function loadConfig(env = process.env) {
+    const removed = Object.entries(REMOVED_VARIABLES)
+        .filter(([name]) => env[name] !== undefined)
+        .map(([name, use]) => `  ${name}: removed in 0.6.0, use ${use}`);
+    const parsed = schema.safeParse(env);
+    // The pre-dispatch credential shape gate (issue #4a). Runs BEFORE the schema verdict is thrown,
+    // so a malformed load is reported alongside (or instead of) the structural problems rather than
+    // being masked by them, and it names the anomaly + the load recipe in one message. Nothing here
+    // dials: the check is pure string inspection.
+    const shapeIssues = [];
+    for (const name of ['AUTOTASK_API_INTEGRATION_CODE', 'AUTOTASK_USERNAME', 'AUTOTASK_SECRET', 'AUTOTASK_IMPERSONATION_RESOURCE_ID']) {
+        const raw = env[name];
+        if (raw === undefined || raw.trim() === '')
+            continue;
+        const anomalies = detectCredentialShape(raw);
+        if (anomalies.length > 0)
+            shapeIssues.push(`  ${name}: ${malformedCredentialBootMessage(name, anomalies, raw.length)}`);
+    }
+    const intake = loadServerCredentials(env);
+    if (intake.sdkProblem !== undefined) {
+        // The SDK's canonical loader refused a value our own check did not name (or named differently).
+        // Only the SDK's machine CODE is referenced: its MESSAGE embeds a value summary
+        // (`credentialValueSummary` -> a length and a two-character prefix, chunk-PBBFMRI5 `shapeError`),
+        // so quoting it would put characters of a secret into the boot log and the doctor-CLI JSON. The
+        // text served is this server's own, value-free: the loader's verdict and the load recipe.
+        shapeIssues.push(`  ${intake.sdkProblem.code}: ${MALFORMED_CREDENTIAL_REFUSAL}`);
+    }
+    if (parsed.success && shapeIssues.length === 0 && removed.length === 0)
+        return parsed.data;
+    const problems = [
+        ...removed,
+        ...(parsed.success ? [] : parsed.error.issues.map((i) => `  ${i.path.join('.') || '(config)'}: ${i.message}`)),
+    ];
+    const all = [...problems, ...shapeIssues];
+    // #73: the stale-variable diagnostics (additive, throw path only — a valid config still boots;
+    // the section is never served on the success path).
+    const unrecognised = unrecognisedAutotaskVars(env);
+    const section = [
+        'AUTOTASK_* env vars:',
+        `  recognised and set: ${Object.keys(CONFIG_FIELDS.shape).filter((k) => k.startsWith('AUTOTASK_') && env[k] !== undefined).sort().join(', ') || 'none'} — the vars this server actually reads (removed names above are not read)`,
+        ...(unrecognised.length > 0
+            ? [
+                `  unrecognised (ignored by this server): ${unrecognised.join(', ')}`,
+                'Unrecognised AUTOTASK_* vars are ignored by this server; if they belong to a newer (or older) server version, check the version this deployment runs, then upgrade or remove them.',
+                'Known legacy renames: AUTOTASK_API_CODE -> set AUTOTASK_API_INTEGRATION_CODE instead (the pinned SDK\'s canonical name).',
+            ]
+            : []),
+    ];
+    const tail = `\n\n${section.join('\n')}`;
+    throw new ConfigError(shapeIssues.length > 0
+        ? `Invalid configuration (credential intake refused a value):\n${all.join('\n')}${tail}`
+        : `Invalid configuration:\n${all.join('\n')}${tail}`);
+}
+//# sourceMappingURL=load.js.map

package/dist/config/parse.d.ts

@@ -0,0 +1,34 @@
+/** Small parsers and predicates the configuration schema uses: hosts, toolsets, the run scope, approval mode (issue #91). */
+import * as z from 'zod';
+/**
+ * A run scope: the companies one operator principal may write in this run. `{all: true}` means the
+ * policy's own scope; company ids are intersected with it, so a run scope can only narrow.
+ */
+export declare const RUN_SCOPE: z.ZodUnion<readonly [z.ZodObject<{
+    all: z.ZodLiteral<true>;
+}, z.core.$strict>, z.ZodObject<{
+    companyIds: z.ZodArray<z.ZodNumber>;
+}, z.core.$strict>]>;
+/** True for an address only this host can reach (the HTTP bind decides what boot requires). */
+export declare function isLoopbackHost(host: string): boolean;
+/** A comma list of hostnames (lowercased, de-duplicated), or undefined when unset or blank. */
+export declare function parseHostList(raw: string | undefined): string[] | undefined;
+/** `AUTOTASK_TOOLSETS` parsed once: a comma list of toolset names, `all` = every toolset. */
+export declare function parseToolsets(raw: string | undefined): string[];
+/**
+ * `AUTOTASK_ALLOWED_BASE_HOSTS` parsed once, here.
+ *
+ * Unset or blank stays `undefined` (no list); otherwise a lowercased, de-duplicated list.
+ * Entry validation (shape + "could match a real hostname") happens in the schema refinement.
+ */
+export declare function parseBaseHosts(raw: string | undefined): string[] | undefined;
+/**
+ * A plausible hostname label (RFC 952/1123): 1-63 lowercase alphanumerics + hyphens, no leading or
+ * trailing hyphen. The `*` wildcard is not a real label: it is legal only as the first label of a
+ * `*.` suffix entry, which the caller strips before delegating here.
+ */
+export declare const HOST_LABEL: RegExp;
+/** Whether an entry could match a real hostname, or only a typo (a silent dead entry). */
+export declare function isPlausibleHost(entry: string): boolean;
+/** Blank-to-undefined preprocessor: `VAR=` (a copied `.env.example` line) means "unset". */
+export declare const blankToUndefined: z.ZodPreprocess<z.ZodString, unknown>;

package/dist/config/parse.js

@@ -0,0 +1,61 @@
+/** Small parsers and predicates the configuration schema uses: hosts, toolsets, the run scope, approval mode (issue #91). */
+import * as z from 'zod';
+import { TOOLSETS } from './constants.js';
+/**
+ * A run scope: the companies one operator principal may write in this run. `{all: true}` means the
+ * policy's own scope; company ids are intersected with it, so a run scope can only narrow.
+ */
+export const RUN_SCOPE = z.union([
+    z.object({ all: z.literal(true) }).strict(),
+    z.object({ companyIds: z.array(z.number().int().positive()).min(1).max(1000) }).strict(),
+]);
+/** True for an address only this host can reach (the HTTP bind decides what boot requires). */
+export function isLoopbackHost(host) {
+    const h = host.toLowerCase().replace(/^\[|\]$/g, '');
+    return h === 'localhost' || h === '::1' || /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/.test(h);
+}
+/** A comma list of hostnames (lowercased, de-duplicated), or undefined when unset or blank. */
+export function parseHostList(raw) {
+    if (raw === undefined || raw.trim() === '')
+        return undefined;
+    return [...new Set(raw.split(',').map((h) => h.trim().toLowerCase()).filter((h) => h.length > 0))];
+}
+/** `AUTOTASK_TOOLSETS` parsed once: a comma list of toolset names, `all` = every toolset. */
+export function parseToolsets(raw) {
+    const names = (raw ?? '')
+        .split(',')
+        .map((name) => name.trim().toLowerCase())
+        .filter((name) => name.length > 0);
+    return names.includes('all') ? [...TOOLSETS] : [...new Set(names)];
+}
+/**
+ * `AUTOTASK_ALLOWED_BASE_HOSTS` parsed once, here.
+ *
+ * Unset or blank stays `undefined` (no list); otherwise a lowercased, de-duplicated list.
+ * Entry validation (shape + "could match a real hostname") happens in the schema refinement.
+ */
+export function parseBaseHosts(raw) {
+    if (raw === undefined || raw.trim() === '')
+        return undefined;
+    const parsed = raw
+        .split(',')
+        .map((host) => host.trim().toLowerCase())
+        .filter((host) => host.length > 0);
+    return [...new Set(parsed)];
+}
+/**
+ * A plausible hostname label (RFC 952/1123): 1-63 lowercase alphanumerics + hyphens, no leading or
+ * trailing hyphen. The `*` wildcard is not a real label: it is legal only as the first label of a
+ * `*.` suffix entry, which the caller strips before delegating here.
+ */
+export const HOST_LABEL = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
+/** Whether an entry could match a real hostname, or only a typo (a silent dead entry). */
+export function isPlausibleHost(entry) {
+    const body = entry.startsWith('*.') ? entry.slice(2) : entry;
+    if (body === '')
+        return false;
+    return body.split('.').every((label) => HOST_LABEL.test(label));
+}
+/** Blank-to-undefined preprocessor: `VAR=` (a copied `.env.example` line) means "unset". */
+export const blankToUndefined = z.preprocess((raw) => (typeof raw === 'string' && raw.trim() === '' ? undefined : raw), z.string());
+//# sourceMappingURL=parse.js.map

package/dist/config/schema.d.ts

@@ -0,0 +1,125 @@
+/** The configuration schema: the field table and the validated Config type (issue #91). */
+import * as z from 'zod';
+/** The approval mode each profile runs under (readonly writes nothing, so there is nothing to approve). */
+export declare function approvalMode(config: Pick<Config, 'AUTOTASK_PROFILE'> & Partial<Pick<Config, 'AUTOTASK_POLICY_FILE'>>): 'off' | 'policy' | 'external';
+export declare const CONFIG_FIELDS: z.ZodObject<{
+    MCP_TRANSPORT: z.ZodDefault<z.ZodEnum<{
+        stdio: "stdio";
+        http: "http";
+    }>>;
+    MCP_HOST: z.ZodPreprocess<z.ZodDefault<z.ZodString>, unknown>;
+    AUTOTASK_HTTP_ALLOWED_HOSTS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    AUTOTASK_HTTP_ALLOWED_ORIGINS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    AUTOTASK_HTTP_AUTH: z.ZodOptional<z.ZodEnum<{
+        tokens: "tokens";
+        gateway: "gateway";
+    }>>;
+    AUTOTASK_HTTP_TOKENS_FILE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_HTTP_RATE_PER_MIN: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_BASE_URL: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    AUTOTASK_API_INTEGRATION_CODE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_USERNAME: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_SECRET: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_IMPERSONATION_RESOURCE_ID: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_ALLOWED_BASE_HOSTS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    AUTOTASK_ALLOW_ANY_BASE_HOST: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false">>;
+    AUTOTASK_PROFILE: z.ZodDefault<z.ZodEnum<{
+        readonly: "readonly";
+        operator: "operator";
+    }>>;
+    AUTOTASK_POLICY_FILE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_STATE_DIR: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_KILL_FILE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_PRINCIPAL: z.ZodPreprocess<z.ZodDefault<z.ZodString>, unknown>;
+    AUTOTASK_RUN_SCOPE: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<{
+        all: true;
+    } | {
+        companyIds: number[];
+    } | undefined, string | undefined>>;
+    AUTOTASK_TOOLSETS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[], string | undefined>>;
+    AUTOTASK_CACHE_PRESET: z.ZodDefault<z.ZodEnum<{
+        on: "on";
+        off: "off";
+    }>>;
+    AUTOTASK_COMPOSITE_NAMES: z.ZodDefault<z.ZodEnum<{
+        on: "on";
+        off: "off";
+    }>>;
+    AUTOTASK_FIELD_CACHE_TTL_MS: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>, unknown>;
+    AUTOTASK_OUTPUT_DIR: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_RATE_LIMIT_PER_HOUR: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_MAX_CONCURRENT: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_TIMEOUT_MS: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_MAX_RETRIES: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    PORT: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+}, z.core.$strip>;
+export declare const schema: z.ZodObject<{
+    MCP_TRANSPORT: z.ZodDefault<z.ZodEnum<{
+        stdio: "stdio";
+        http: "http";
+    }>>;
+    MCP_HOST: z.ZodPreprocess<z.ZodDefault<z.ZodString>, unknown>;
+    AUTOTASK_HTTP_ALLOWED_HOSTS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    AUTOTASK_HTTP_ALLOWED_ORIGINS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    AUTOTASK_HTTP_AUTH: z.ZodOptional<z.ZodEnum<{
+        tokens: "tokens";
+        gateway: "gateway";
+    }>>;
+    AUTOTASK_HTTP_TOKENS_FILE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_HTTP_RATE_PER_MIN: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_BASE_URL: z.ZodPreprocess<z.ZodOptional<z.ZodString>, unknown>;
+    AUTOTASK_API_INTEGRATION_CODE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_USERNAME: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_SECRET: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_IMPERSONATION_RESOURCE_ID: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_ALLOWED_BASE_HOSTS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[] | undefined, string | undefined>>;
+    AUTOTASK_ALLOW_ANY_BASE_HOST: z.ZodPipe<z.ZodDefault<z.ZodEnum<{
+        true: "true";
+        false: "false";
+    }>>, z.ZodTransform<boolean, "true" | "false">>;
+    AUTOTASK_PROFILE: z.ZodDefault<z.ZodEnum<{
+        readonly: "readonly";
+        operator: "operator";
+    }>>;
+    AUTOTASK_POLICY_FILE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_STATE_DIR: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_KILL_FILE: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_PRINCIPAL: z.ZodPreprocess<z.ZodDefault<z.ZodString>, unknown>;
+    AUTOTASK_RUN_SCOPE: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<{
+        all: true;
+    } | {
+        companyIds: number[];
+    } | undefined, string | undefined>>;
+    AUTOTASK_TOOLSETS: z.ZodPipe<z.ZodOptional<z.ZodString>, z.ZodTransform<string[], string | undefined>>;
+    AUTOTASK_CACHE_PRESET: z.ZodDefault<z.ZodEnum<{
+        on: "on";
+        off: "off";
+    }>>;
+    AUTOTASK_COMPOSITE_NAMES: z.ZodDefault<z.ZodEnum<{
+        on: "on";
+        off: "off";
+    }>>;
+    AUTOTASK_FIELD_CACHE_TTL_MS: z.ZodPreprocess<z.ZodOptional<z.ZodNumber>, unknown>;
+    AUTOTASK_OUTPUT_DIR: z.ZodOptional<z.ZodPreprocess<z.ZodString, unknown>>;
+    AUTOTASK_RATE_LIMIT_PER_HOUR: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_MAX_CONCURRENT: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_TIMEOUT_MS: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    AUTOTASK_MAX_RETRIES: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
+    PORT: z.ZodDefault<z.ZodCoercedNumber<unknown>>;
+    LOG_LEVEL: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        debug: "debug";
+        info: "info";
+        warn: "warn";
+    }>>;
+}, z.core.$strip>;
+export type Config = z.infer<typeof schema>;