@khorsheed/dsh-local-agent-kimi 0.1.0-rc.6

package/lib/types/credential-guard.js

@@ -0,0 +1,107 @@
+/**
+ * Kimi credential sentinel. The kimi CLI occasionally wipes
+ * `credentials/kimi-code.json` into an empty shell (both tokens zero-length)
+ * on its own failure paths — observed twice in production, each time killing
+ * every later delegation with "Authentication required" until someone
+ * restored the file by hand. The sentinel:
+ *
+ * - backs the file up whenever a VALID credential is observed (the backup
+ *   lives inside `credentials/` so the family's logout — a directory delete —
+ *   clears it too);
+ * - restores the backup when the file is an exact empty shell (both tokens
+ *   empty strings) — the only corruption signature we trust;
+ * - logs every state transition with a process snapshot, so the next wipe
+ *   can be attributed (which process, at which moment).
+ *
+ * Restore is deliberately narrow: a revoked-elsewhere credential never takes
+ * the empty-shell shape, and a stale backup at worst produces one more loud
+ * 401, never silent misbehavior.
+ * @module @khorsheed/dsh-local-agent-kimi/credential-guard
+ */
+import { copyFile, readFile, stat, writeFile } from 'node:fs/promises';
+import { execFile } from 'node:child_process';
+import { join } from 'node:path';
+/** The credential file inside the scoped home, and its sentinel backup. */
+const CREDENTIAL_REL = join('credentials', 'kimi-code.json');
+const BACKUP_REL = `${CREDENTIAL_REL}.bak`;
+/** Last observed state signature per home (`${mtimeMs}:${kind}`) — transition logging. */
+const lastSeen = new Map();
+/** A one-line process snapshot for wipe attribution (kimi/dsh processes only). */
+function processSnapshot() {
+    return new Promise((resolve) => {
+        execFile('ps', ['-eo', 'pid,ppid,etime,command'], { timeout: 5_000 }, (error, stdout) => {
+            if (error !== null) {
+                resolve(`(ps failed: ${error.message})`);
+                return;
+            }
+            const lines = stdout.split('\n').filter((line) => /\bkimi\b|dsh/.test(line) && !line.includes('grep')).slice(0, 12);
+            resolve(lines.join(' ; '));
+        });
+    });
+}
+/** Classify the credential file's current content. */
+async function observe(file) {
+    let raw;
+    try {
+        raw = await readFile(file, 'utf8');
+    }
+    catch {
+        return { state: 'absent', mtimeMs: 0 };
+    }
+    let mtimeMs = 0;
+    try {
+        mtimeMs = (await stat(file)).mtimeMs;
+    }
+    catch { /* keep 0 */ }
+    try {
+        const parsed = JSON.parse(raw);
+        const empty = (v) => typeof v === 'string' && v.length === 0;
+        if (empty(parsed.access_token) && empty(parsed.refresh_token))
+            return { state: 'empty-shell', mtimeMs };
+        return { state: 'valid', mtimeMs };
+    }
+    catch {
+        // Unparseable is neither valid nor the known shell: treat as absent and
+        // never restore over it (unknown corruption shape — leave it for a human).
+        return { state: 'absent', mtimeMs };
+    }
+}
+/**
+ * Guard the scoped home's kimi credential: back up a valid file, restore the
+ * backup over an empty shell, log transitions.
+ * @param homeDir - the `kimi` harness's scoped home.
+ * @param log - warn channel (plugin logger when available).
+ * @returns true when a usable credential exists after the guard ran.
+ */
+export async function guardKimiCredential(homeDir, log) {
+    const file = join(homeDir, CREDENTIAL_REL);
+    const backup = join(homeDir, BACKUP_REL);
+    const { state, mtimeMs } = await observe(file);
+    const signature = `${mtimeMs}:${state}`;
+    const previous = lastSeen.get(homeDir);
+    lastSeen.set(homeDir, signature);
+    if (state === 'valid') {
+        if (previous !== undefined && previous !== signature) {
+            log?.(`local-agent-kimi: credential refreshed (mtime ${new Date(mtimeMs).toISOString()}), snapshotting the backup`);
+        }
+        await writeFile(backup, await readFile(file), { mode: 0o600 });
+        return true;
+    }
+    if (state === 'empty-shell') {
+        const snapshot = await processSnapshot();
+        log?.(`local-agent-kimi: CREDENTIAL EMPTY SHELL detected (mtime ${new Date(mtimeMs).toISOString()}); previous state ${previous ?? 'unknown'}; processes: ${snapshot}`);
+        let backupState = 'absent';
+        try {
+            backupState = (await observe(backup)).state;
+        }
+        catch { /* absent */ }
+        if (backupState === 'valid') {
+            await copyFile(backup, file);
+            log?.('local-agent-kimi: credential restored from the sentinel backup — the next delegation should succeed');
+            return true;
+        }
+        log?.('local-agent-kimi: no usable backup to restore; the harness needs a fresh login');
+        return false;
+    }
+    return false;
+}

package/lib/types/index.d.ts

@@ -0,0 +1,69 @@
+/**
+ * Kimi Code harness instantiation of the local-agent family. Registers the
+ * `kimi` harness into the core registry: scoped home under the shared homes
+ * root (`KIMI_CODE_HOME`), device-code login through `kimi login`, and the
+ * `session_index.jsonl` records adapter. Delegation mounts through the
+ * `kimi-cli` provider (one-shot `kimi -p` under the scoped home); the
+ * bundle patch's `tool-subagent-kimi` row puts the `subagent_kimi` tool on
+ * the profile root, so every agent preset can delegate without variants.
+ *
+ * @module @khorsheed/dsh-local-agent-kimi
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+/** Stable Cordis plugin name; the bundle patch row id. */
+export declare const name = "local-agent-kimi";
+/** Services required before the harness can register. */
+export declare const inject: string[];
+/** Plugin config: the model every round runs, plus the live driver. */
+export interface Config {
+    /**
+     * The model every delegation round starts the CLI with (`kimi -m <model>`;
+     * the resident `kimi acp`, which takes no model flag, gets the scoped
+     * config's `default_model` rewritten before each spawn instead). The value
+     * must name a model the scoped config.toml defines (a `[models."…"]` key).
+     *
+     * Absent — the default — passes no model at all: `default_model` decides,
+     * exactly as it did before this key rode every round. The settings card
+     * writes the same key, so a change applies to the next round without a
+     * reload.
+     *
+     * This key ALSO still seeds a FRESH scoped home's `default_model` when
+     * there is no user config to mirror, which is all it used to do.
+     */
+    model?: string;
+    /**
+     * Reasoning effort a FRESH scoped home's config.toml pins (`[thinking]
+     * effort` and the model's `default_effort`). Provision-time only: an
+     * existing config is respected untouched, exactly like the mirrored model.
+     * Default 'high' — the value the pre-config-item provisioning hardcoded,
+     * so the default changes nothing.
+     */
+    thinkingEffort?: 'low' | 'high' | 'max';
+    /**
+     * Live driver: keep one resident `kimi acp` process per member and drive
+     * turns over ACP (runtime-level graceful cancel, push-triggered mirroring)
+     * instead of one `kimi -p` process per round. Default off; the exec
+     * one-shot stays the fallback whenever the channel cannot come up.
+     */
+    live?: boolean;
+    /** Idle lifetime of an unused resident runtime before reclaim. */
+    liveIdleMs?: number;
+    /** @deprecated Accepted for old profiles; live output is always incremental. */
+    liveMirrorGranularity?: 'event' | 'token';
+    /** Model identifiers the settings card saved before (settings field). */
+    recentModels?: readonly string[];
+}
+export declare const Config: z;
+/**
+ * Settings namespace for the settings-page card. The Cordis config feeds the
+ * composition `base` layer, so a field absent from the user layer inherits the
+ * YAML value — the card only ever stores deliberate overrides.
+ */
+export declare const KIMI_SETTINGS_NAMESPACE = "local-agent-kimi";
+/**
+ * Register the Kimi harness into the local-agent registry.
+ * @param ctx - plugin context carrying the registry.
+ */
+export declare function apply(ctx: Context, config: Config): void;
+//# sourceMappingURL=index.d.ts.map

package/lib/types/index.js

@@ -0,0 +1,270 @@
+/**
+ * Kimi Code harness instantiation of the local-agent family. Registers the
+ * `kimi` harness into the core registry: scoped home under the shared homes
+ * root (`KIMI_CODE_HOME`), device-code login through `kimi login`, and the
+ * `session_index.jsonl` records adapter. Delegation mounts through the
+ * `kimi-cli` provider (one-shot `kimi -p` under the scoped home); the
+ * bundle patch's `tool-subagent-kimi` row puts the `subagent_kimi` tool on
+ * the profile root, so every agent preset can delegate without variants.
+ *
+ * @module @khorsheed/dsh-local-agent-kimi
+ */
+import z from '@deepseek-ai/schemastery';
+import { settingsFace, vol } from '@khorsheed/dsh-local-agent';
+import { endpointHost } from '@khorsheed/dsh-local-agent/types';
+import { KimiCliProvider, kimiCliVersion } from './kimi-cli-provider.js';
+import { DEFAULT_LIVE_IDLE_MS } from './live-driver.js';
+import { LiveDriverSwitch } from './live-switch.js';
+import { KimiModelCatalog } from './model-catalog.js';
+import { KimiModelBroker } from './model-broker.js';
+import { kimiAuthenticated, kimiCredentialStamp, listKimiSessions } from './records.js';
+import { removeLegacyVariants } from './preset-tools.js';
+import { DEFAULT_THINKING_EFFORT, ensureKimiPermissions, kimiLogout, KIMI_MANAGED_BASE_URL, provisionKimiConfig, readKimiAutoApprove, readKimiBaseUrl, readKimiDefaultModel, readKimiReasoningEffort, } from './provision.js';
+import { findKimiSessionDir, readKimiTranscript, renderTranscript } from './session-view.js';
+/** Stable Cordis plugin name; the bundle patch row id. */
+export const name = 'local-agent-kimi';
+/** Services required before the harness can register. */
+export const inject = ['localAgent', 'subagents', 'subprocess', 'settings'];
+/**
+ * The settings fields (`live`, `liveMirrorGranularity`, `model`,
+ * `recentModels`) ride the plugin Config, marked `.volatile()` where the
+ * host's schemastery has it (3.18.4+, the rc.1 line — probed, never sniffed):
+ * there the SettingsForms writes hot-track the running fiber's Volatile
+ * references without a remount, and the official one-shot import moves an old
+ * settings.yaml section into this row's config. On 0.1.5 the call is absent,
+ * the fields stay plain config keys (a semantic superset — the profile row
+ * can now preset them too), and the legacy settings namespace below carries
+ * the user layer exactly as before.
+ */
+const SETTINGS_FIELDS = {
+    live: z.boolean().default(false),
+    liveMirrorGranularity: z.union([z.const('event'), z.const('token')]).default('token'),
+    // `model` deliberately carries NO default: an unset key must resolve to
+    // undefined, which is what keeps the pre-key behavior byte-identical.
+    model: z.string(),
+    recentModels: z.array(z.string()).default([]),
+};
+/** Mark one schema field volatile when the host's schemastery has the method (rc.1), pass it through plain when not (0.1.5). */
+function volatilize(field) {
+    return typeof field.volatile === 'function' ? field.volatile() : field;
+}
+// Bare `z` annotation: `z<Config>` fails schemastery 3.18.4's variance under
+// exactOptionalPropertyTypes (TS2375) and dropping the annotation trips
+// TS2742; the interface stays the apply signature's contract.
+export const Config = z.object({
+    model: volatilize(SETTINGS_FIELDS.model),
+    thinkingEffort: z.union([z.const('low'), z.const('high'), z.const('max')]),
+    live: volatilize(SETTINGS_FIELDS.live),
+    liveIdleMs: z.number().default(DEFAULT_LIVE_IDLE_MS),
+    liveMirrorGranularity: volatilize(SETTINGS_FIELDS.liveMirrorGranularity),
+    recentModels: volatilize(SETTINGS_FIELDS.recentModels),
+});
+/**
+ * Settings namespace for the settings-page card. The Cordis config feeds the
+ * composition `base` layer, so a field absent from the user layer inherits the
+ * YAML value — the card only ever stores deliberate overrides.
+ */
+export const KIMI_SETTINGS_NAMESPACE = 'local-agent-kimi';
+/**
+ * The card's schema; field defaults are the innermost layer below `base`.
+ * `model` deliberately carries NO default: an unset key must resolve to
+ * undefined, which is what keeps the pre-key behavior byte-identical.
+ */
+const KIMI_SETTINGS_SCHEMA = z.object(SETTINGS_FIELDS);
+/**
+ * Handle the harness's extra subcommands: `session <id>` renders a kimi
+ * session transcript. Returns synchronously with undefined for any input
+ * that is not this harness's own.
+ * @param input - the trimmed subcommand input.
+ * @param invocation - the full command invocation.
+ * @returns the command result promise, or undefined when not this harness's.
+ */
+function handleSubcommand(input, invocation) {
+    const [verb] = input.split(/\s+/);
+    if (verb === 'session')
+        return handleSessionSubcommand(input, invocation);
+    return undefined;
+}
+/** Run one `session` subcommand: render the transcript of a kimi session. */
+async function handleSessionSubcommand(input, invocation) {
+    const id = input.split(/\s+/)[1];
+    if (id === undefined) {
+        return { kind: 'error', text: 'Usage: /kimi session <session-id> (see /kimi sessions for ids)' };
+    }
+    const homeDir = invocation.agent.ctx.localAgent.homeDir('kimi');
+    const sessionDir = await findKimiSessionDir(homeDir, id);
+    if (sessionDir === undefined) {
+        return { kind: 'error', text: `no kimi session "${id}" in the scoped home` };
+    }
+    try {
+        const transcript = await readKimiTranscript(sessionDir);
+        return { kind: 'success', text: renderTranscript(transcript) };
+    }
+    catch (error) {
+        return { kind: 'error', text: error instanceof Error ? error.message : String(error) };
+    }
+}
+/**
+ * Register the Kimi harness into the local-agent registry.
+ * @param ctx - plugin context carrying the registry.
+ */
+export function apply(ctx, config) {
+    ctx.effect(() => {
+        const homeDir = ctx.localAgent.homeDir('kimi');
+        // The ACP server refuses to authenticate without provider/model config;
+        // provision a redacted config once so the scoped home stands alone. The
+        // reasoning effort rides the same provisioning (fresh homes only).
+        const thinkingEffort = config.thinkingEffort ?? DEFAULT_THINKING_EFFORT;
+        // Earlier versions bootstrapped <base>-kimi preset variants; the tool row
+        // now mounts at the profile root, so remove the leftovers once.
+        void removeLegacyVariants(ctx).catch((error) => {
+            ctx.logger.warn(`local-agent-kimi: legacy preset cleanup failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        // The one-shot CLI provider delegates through `kimi -p` in the scoped
+        // home; ensure the scoped config allows the subagent's tool use. Chained
+        // AFTER provisioning: both used to fire concurrently and the permission
+        // bootstrap raced the config write — on a fresh home it could read
+        // ENOENT and return early, leaving the Bash(*) allow rule unwritten
+        // until the next boot (first-boot delegations answered without tools).
+        void provisionKimiConfig(homeDir, vol(config.model) ?? 'kimi-code/k3', thinkingEffort)
+            .then(() => ensureKimiPermissions(homeDir))
+            .catch((error) => {
+            ctx.logger.warn(`local-agent-kimi: config provisioning failed: ${error instanceof Error ? error.message : String(error)}`);
+        });
+        // The live driver is settings-driven: the settings card's toggle (user
+        // layer over the YAML composition base) swaps driver generations without
+        // a reload. Toggling OFF drains the retiring generation — new rounds fall
+        // back to exec, in-flight rounds finish on their runtime, idle runtimes
+        // are reclaimed at once. Legacy granularity settings are accepted but ignored.
+        // The settings face hides the two host lines: 0.1.5 serves the legacy
+        // namespace scope (register + base); rc.1 reads the row config's volatile
+        // fields and re-reads on `settings/document-updated`. Both hot-apply the
+        // card's writes without a reload.
+        const readSettings = () => {
+            const model = vol(config.model);
+            const recentModels = vol(config.recentModels);
+            return {
+                live: vol(config.live) ?? false,
+                liveMirrorGranularity: vol(config.liveMirrorGranularity) ?? 'token',
+                ...model === undefined ? {} : { model },
+                ...recentModels === undefined ? {} : { recentModels },
+            };
+        };
+        const legacyBase = {};
+        for (const field of ['live', 'liveMirrorGranularity', 'model']) {
+            const value = vol(config[field]);
+            if (value !== undefined)
+                legacyBase[field] = value;
+        }
+        const face = settingsFace(ctx, {
+            namespace: KIMI_SETTINGS_NAMESPACE,
+            legacySchema: KIMI_SETTINGS_SCHEMA,
+            legacyBase,
+            read: readSettings,
+        });
+        // The model is read PER ROUND, not captured at apply: the settings card
+        // writes the same namespace field, so a change has to reach the next
+        // delegation without a plugin reload — exactly like the live toggle.
+        // Blank is not a model: a whitespace-only value means "unset", which is
+        // the pre-key argv.
+        const resolveModel = () => {
+            const model = face.get().model?.trim();
+            return model === undefined || model === '' ? undefined : model;
+        };
+        // The model broker owns the per-member state (session-level overrides,
+        // start models) and the gateway-facing surface. The live driver's spawn
+        // resolver defers to it through a closure because the broker itself needs
+        // the switch (a switch retires runtimes through it) — the circularity is
+        // construction-order only, and no round can run before both exist.
+        let broker;
+        const liveSwitch = new LiveDriverSwitch(ctx, face, config.liveIdleMs, child => broker.spawnModel(child));
+        const modelCatalog = new KimiModelCatalog(childSessionId => {
+            const record = childSessionId === undefined ? undefined : ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId);
+            const native = childSessionId === undefined ? undefined : liveSwitch.memberRuntimeConfiguration(childSessionId);
+            return {
+                homeDir: ctx.localAgent.homeDir('kimi', record?.scope),
+                ...record?.cwd === undefined ? {} : { cwd: record.cwd },
+                ...native === undefined ? {} : { native },
+            };
+        });
+        broker = new KimiModelBroker(ctx, {
+            homeDir: childSessionId => ctx.localAgent.homeDir('kimi', childSessionId === undefined ? undefined : (ctx.localAgent.memberBinding?.(childSessionId) ?? ctx.localAgent.getDelegation(childSessionId))?.scope),
+            catalog: modelCatalog,
+            settingsModel: resolveModel,
+            recentModels: () => face.get().recentModels ?? [],
+            isLive: () => face.get().live,
+            liveSwitch,
+        });
+        const disposeProvider = ctx.subagents.registerProvider(new KimiCliProvider(ctx, liveSwitch.resolve, resolveModel, broker));
+        const disposeHarness = ctx.localAgent.register({
+            prepareMember: async ({ binding, childSession, configuration, signal }) => {
+                const driver = liveSwitch.resolve(binding.childSessionId);
+                if (driver === undefined || driver.disabled)
+                    throw new Error('Enable the native live harness before preparing a coordinator');
+                await driver.prepare({ cwd: binding.cwd, homeDir: ctx.localAgent.homeDir('kimi', binding.scope), childSession,
+                    parentSessionId: binding.parentSessionId, configuration: configuration.resolved, }, signal);
+            },
+            name: 'kimi',
+            displayName: 'Kimi Code',
+            homeEnvVar: 'KIMI_CODE_HOME',
+            delegationProvider: 'kimi-cli',
+            login: { command: 'kimi', args: ['login'] },
+            records: { listSessions: homeDir => listKimiSessions(homeDir) },
+            // A NAMED scope's directory is provisioned through this hook when the
+            // registry materializes it — the same provider/model config and
+            // permission bootstrap the default scope gets from the apply above, in
+            // the same order (the permission write reads the config file).
+            provision: async (scopedHome) => {
+                await provisionKimiConfig(scopedHome, vol(config.model) ?? 'kimi-code/k3', thinkingEffort);
+                await ensureKimiPermissions(scopedHome);
+            },
+            isAuthenticated: kimiAuthenticated,
+            credentialStamp: kimiCredentialStamp,
+            logout: kimiLogout,
+            subcommand: handleSubcommand,
+            // The model surface: the settings card reads the memberless info, the
+            // member composer reads/switches per member. Registered unconditionally —
+            // the gateway answers null only for harnesses WITHOUT one.
+            modelBroker: broker,
+            // The eval snapshot reads the scoped config as-is — it is authoritative
+            // once provisioned, so a person-edited (or user-mirrored) effort and
+            // endpoint report what actually applies, not what the config item
+            // would have written. The MODEL is the one exception, and the family's
+            // fixed order says why: a set `model` key rides every round's launch,
+            // so it beats the file it is about to overrule; with no key, the
+            // scoped `default_model` is what runs.
+            // The directory is a PARAMETER, not the apply-time capture: a status
+            // read (or an evaluation snapshot) of a named scope must report the
+            // config that scope's rounds would run with.
+            effectiveSettings: async (scopedHome) => {
+                const [reasoningEffort, baseUrl, autoApprove, defaultModel, cliVersion] = await Promise.all([
+                    readKimiReasoningEffort(scopedHome).catch(() => undefined),
+                    readKimiBaseUrl(scopedHome).catch(() => undefined),
+                    readKimiAutoApprove(scopedHome).catch(() => false),
+                    readKimiDefaultModel(scopedHome).catch(() => undefined),
+                    kimiCliVersion(ctx, scopedHome).catch(() => undefined),
+                ]);
+                // The managed endpoint IS kimi's own service — routing through it is
+                // the default, not a pinned custom route.
+                const custom = baseUrl !== undefined && baseUrl !== KIMI_MANAGED_BASE_URL;
+                const baseUrlHost = custom ? endpointHost(baseUrl) : undefined;
+                const model = resolveModel() ?? defaultModel;
+                return {
+                    drive: face.get().live ? 'live' : 'exec',
+                    autoApprove,
+                    ...reasoningEffort !== undefined ? { reasoningEffort } : {},
+                    baseUrlSet: custom,
+                    ...baseUrlHost !== undefined ? { baseUrlHost } : {},
+                    ...model !== undefined ? { model } : {},
+                    ...cliVersion !== undefined ? { cliVersion } : {},
+                };
+            },
+        });
+        return () => {
+            modelCatalog.dispose();
+            disposeProvider();
+            disposeHarness();
+            liveSwitch.dispose();
+        };
+    }, 'local-agent-kimi: harness');
+}

package/lib/types/invariant.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Package-owned invariant companion for `@khorsheed/dsh-local-agent-kimi`.
+ * @module @khorsheed/dsh-local-agent-kimi/invariant
+ */
+import type { Context } from '@deepseek-ai/cordis';
+/** Cordis companion plugin name. */
+export declare const name = "local-agent-kimi-invariant";
+/** Service required before the companion can reserve package ownership. */
+export declare const inject: string[];
+/**
+ * Register this package's invariant companion.
+ * @param ctx - plugin context carrying the invariant registry.
+ * @returns the installed registration's disposer.
+ */
+export declare const apply: (ctx: Context) => Promise<() => void>;
+//# sourceMappingURL=invariant.d.ts.map

package/lib/types/invariant.js

@@ -0,0 +1,33 @@
+/**
+ * Package-owned invariant companion for `@khorsheed/dsh-local-agent-kimi`.
+ * @module @khorsheed/dsh-local-agent-kimi/invariant
+ */
+const PACKAGE_NAME = '@khorsheed/dsh-local-agent-kimi';
+/** Cordis companion plugin name. */
+export const name = 'local-agent-kimi-invariant';
+/** Service required before the companion can reserve package ownership. */
+export const inject = ['invariants'];
+/**
+ * The kimi harness definition is this bundle's contract with the core
+ * registry: whenever a `kimi` harness registers, its scoped-home variable must
+ * be the one this bundle pins.
+ */
+const install = (ctx, fail) => {
+    ctx.on('internal/dispatch', (_mode, eventName, args) => {
+        if (eventName !== 'localAgent/harness-added')
+            return;
+        const harness = args[0];
+        if (harness.name !== 'kimi')
+            return;
+        if (harness.homeEnvVar !== 'KIMI_CODE_HOME') {
+            fail('kimi harness registered with a home env other than the local-agent-kimi contract');
+        }
+    }, { global: true });
+};
+/**
+ * Register this package's invariant companion.
+ * @param ctx - plugin context carrying the invariant registry.
+ * @returns the installed registration's disposer.
+ */
+export const apply = (ctx) => Promise.resolve(ctx.invariants.register(PACKAGE_NAME, install));
+/* jscpd:ignore-end */