@timekast/factory 2.3.1 → 2.5.0

package/dist/lib/prune-tiers.js

@@ -0,0 +1,253 @@
+/**
+ * The CLI's reader of `.claude/policy/prune-tiers.json` (`factory prune`) — which kit paths a
+ * pruned repo shares with its collaborators and which stay local to the members.
+ *
+ * TWIN of `scripts/tools/lib/prune-tiers.mjs`, which the pre-commit guard and skill-lint use:
+ * the published CLI cannot import repo code, so the rule lives twice and
+ * `cli/tests/unit/prune-tiers-parity.test.ts` runs one corpus through both. Change one, change
+ * the other.
+ *
+ * The rule: an entry is a path pattern; a trailing `/` names a directory (everything below
+ * it), otherwise one file; `*` matches within a single segment. The matching entry with the
+ * most segments decides (`restrict` | `share`); none → `unclassified`; a tie between the two
+ * kinds → `ambiguous`.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CLIError } from './cli-error.js';
+import { MANAGED_BLOCK_END, MANAGED_BLOCK_START, PRUNE_FILE, TIMEKAST_DIR } from './constants.js';
+/** Repo-relative path of the registry. */
+export const PRUNE_TIERS_PATH = '.claude/policy/prune-tiers.json';
+/** Repo-relative path of the switch. */
+export const PRUNE_MARKER_PATH = `${TIMEKAST_DIR}/${PRUNE_FILE}`;
+/** The tier `prepare` applies when none is named — the only one today. */
+export const DEFAULT_PRUNE_TIER = 'collab';
+/**
+ * Markers of the block CMLL's cut wrote by hand before this command existed. `syncManagedBlock`
+ * only knows the kit's markers, so it would add a second block beside this one; `prepare`
+ * removes it first.
+ */
+export const LEGACY_COLLAB_START = '# >>> timekast:collab';
+export const LEGACY_COLLAB_END = '# <<< timekast:collab';
+function segmentsOf(entry) {
+    return entry.replace(/\/$/, '').split('/');
+}
+function segmentMatches(pattern, segment) {
+    if (!pattern.includes('*'))
+        return pattern === segment;
+    const rx = new RegExp(`^${pattern
+        .split('*')
+        .map((part) => part.replace(/[.+?^${}()|[\]\\]/g, '\\$&'))
+        .join('[^/]*')}$`);
+    return rx.test(segment);
+}
+/** Does `entry` match `relPath`? A directory entry matches anything strictly below it. */
+export function entryMatches(entry, relPath) {
+    const isDir = entry.endsWith('/');
+    const want = segmentsOf(entry);
+    const have = relPath.split('/');
+    if (isDir ? have.length <= want.length : have.length !== want.length)
+        return false;
+    return want.every((pattern, i) => segmentMatches(pattern, have[i]));
+}
+/** Classify one repo-relative POSIX path under a tier. */
+export function classifyPath(tier, relPath) {
+    let bestDepth = -1;
+    let kinds = new Set();
+    for (const kind of ['restrict', 'share']) {
+        for (const entry of tier[kind]) {
+            if (!entryMatches(entry, relPath))
+                continue;
+            const depth = segmentsOf(entry).length;
+            if (depth > bestDepth) {
+                bestDepth = depth;
+                kinds = new Set([kind]);
+            }
+            else if (depth === bestDepth) {
+                kinds.add(kind);
+            }
+        }
+    }
+    if (kinds.size === 0)
+        return 'unclassified';
+    if (kinds.size > 1)
+        return 'ambiguous';
+    return [...kinds][0];
+}
+export function isRestricted(tier, relPath) {
+    return classifyPath(tier, relPath) === 'restrict';
+}
+/** Form errors of a parsed registry (empty = valid). Mirror of the `.mjs` validator. */
+export function validatePruneTiers(data) {
+    const errors = [];
+    if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+        return ['(root) — must be an object'];
+    }
+    const tiers = data.tiers;
+    if (typeof tiers !== 'object' || tiers === null || Array.isArray(tiers)) {
+        return ['tiers — must be an object of named tiers'];
+    }
+    if (Object.keys(tiers).length === 0)
+        errors.push('tiers — must declare at least one tier');
+    for (const [name, raw] of Object.entries(tiers)) {
+        if (!/^[a-z][a-z0-9-]*$/.test(name)) {
+            errors.push(`tiers.${name} — the tier name must be kebab-case`);
+        }
+        if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
+            errors.push(`tiers.${name} — must be an object`);
+            continue;
+        }
+        const tier = raw;
+        for (const key of Object.keys(tier)) {
+            if (!['description', 'restrict', 'share'].includes(key)) {
+                errors.push(`tiers.${name}.${key} — unknown key (allowed: description, restrict, share)`);
+            }
+        }
+        for (const kind of ['restrict', 'share']) {
+            const list = tier[kind];
+            if (!Array.isArray(list) || list.length === 0) {
+                errors.push(`tiers.${name}.${kind} — must be a non-empty array of path patterns`);
+                continue;
+            }
+            list.forEach((entry, i) => {
+                if (typeof entry !== 'string' || entry.trim() !== entry || entry === '') {
+                    errors.push(`tiers.${name}.${kind}[${i}] — must be a non-empty string without surrounding spaces`);
+                    return;
+                }
+                if (entry.startsWith('/') || entry.includes('\\') || entry.includes('//')) {
+                    errors.push(`tiers.${name}.${kind}[${i}] — "${entry}" must be repo-relative, POSIX`);
+                }
+                if (/[?[\]{}!]/.test(entry) || entry.includes('**')) {
+                    errors.push(`tiers.${name}.${kind}[${i}] — "${entry}" may only use \`*\` within one segment`);
+                }
+                if (segmentsOf(entry).some((seg) => seg === '' || seg === '.' || seg === '..')) {
+                    errors.push(`tiers.${name}.${kind}[${i}] — "${entry}" has an empty or relative segment`);
+                }
+            });
+        }
+        if (!Array.isArray(tier.restrict) || !Array.isArray(tier.share))
+            continue;
+        const restrict = tier.restrict;
+        const share = tier.share;
+        const all = [...restrict, ...share];
+        const dupes = all.filter((e, i) => all.indexOf(e) !== i);
+        for (const dupe of new Set(dupes)) {
+            errors.push(`tiers.${name} — "${dupe}" is listed more than once`);
+        }
+        for (const entry of share) {
+            for (const dir of restrict.filter((r) => r.endsWith('/'))) {
+                if (!entry.startsWith(dir))
+                    continue;
+                if (segmentsOf(entry).length !== segmentsOf(dir).length + 1) {
+                    errors.push(`tiers.${name}.share — "${entry}" sits more than one level below the restricted ` +
+                        `directory "${dir}"; a re-include only works for a direct child`);
+                }
+            }
+        }
+        for (const entry of restrict) {
+            for (const dir of restrict.filter((r) => r !== entry && r.endsWith('/'))) {
+                if (entry.startsWith(dir)) {
+                    errors.push(`tiers.${name}.restrict — "${entry}" is already covered by "${dir}"; drop one`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+/** The tier's `.gitignore` lines, without markers. Mirror of the `.mjs` `gitignoreLines`. */
+export function gitignoreLines(tier) {
+    const depth = (e) => segmentsOf(e).length;
+    const ordered = [...tier.restrict].sort((a, b) => depth(a) - depth(b) || a.localeCompare(b));
+    const lines = [];
+    for (const entry of ordered) {
+        const children = entry.endsWith('/')
+            ? tier.share.filter((s) => s.startsWith(entry)).sort()
+            : [];
+        if (children.length === 0) {
+            lines.push(`/${entry}`);
+            continue;
+        }
+        lines.push(`/${entry}*`);
+        for (const child of children)
+            lines.push(`!/${child}`);
+    }
+    return lines;
+}
+/** The managed `.gitignore` block (markers inclusive) of one tier. */
+export function renderGitignoreBlock(tierName, tier) {
+    return [
+        `${MANAGED_BLOCK_START} (prune tier \`${tierName}\` — regenerated by \`factory prune\` and \`factory update\`; do not edit) >>>`,
+        '# Kit paths kept LOCAL to the members of the org: they never enter this repository, so a',
+        '# collaborator never sees them. Generated from .claude/policy/prune-tiers.json; the switch',
+        '# is .timekast/prune.json. Anything not listed here is shared.',
+        ...gitignoreLines(tier),
+        `${MANAGED_BLOCK_END} <<<`,
+    ].join('\n');
+}
+/** Remove the hand-written `timekast:collab` block (markers inclusive), if present. */
+export function stripLegacyCollabBlock(content) {
+    const lines = content.replace(/\r\n/g, '\n').split('\n');
+    const start = lines.findIndex((l) => l.trimStart().startsWith(LEGACY_COLLAB_START));
+    if (start === -1)
+        return { content, removed: false };
+    let end = lines.length - 1;
+    for (let i = start + 1; i < lines.length; i++) {
+        if (lines[i].trimStart().startsWith(LEGACY_COLLAB_END)) {
+            end = i;
+            break;
+        }
+    }
+    const kept = [...lines.slice(0, start), ...lines.slice(end + 1)];
+    while (kept.length > 0 && kept[kept.length - 1].trim() === '')
+        kept.pop();
+    return { content: kept.length > 0 ? `${kept.join('\n')}\n` : '', removed: true };
+}
+/** Read + validate the registry under `dir` (a repo root or a staged tarball). */
+export function readPruneTiers(dir) {
+    const file = path.join(dir, PRUNE_TIERS_PATH);
+    if (!existsSync(file)) {
+        throw new CLIError(`No existe \`${PRUNE_TIERS_PATH}\`. Corre \`factory update\` para traer la versión del kit que lo incluye.`);
+    }
+    let data;
+    try {
+        data = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch (err) {
+        throw new CLIError(`\`${PRUNE_TIERS_PATH}\` no es JSON válido: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    const errors = validatePruneTiers(data);
+    if (errors.length > 0) {
+        throw new CLIError(`\`${PRUNE_TIERS_PATH}\` tiene errores de forma:\n  • ${errors.join('\n  • ')}`);
+    }
+    return data;
+}
+/** Look up one tier, naming the valid ones when it does not exist. */
+export function getTier(tiers, name) {
+    const tier = tiers.tiers[name];
+    if (!tier) {
+        throw new CLIError(`El tier \`${name}\` no existe en \`${PRUNE_TIERS_PATH}\`. Tiers disponibles: ${Object.keys(tiers.tiers).join(', ')}.`);
+    }
+    return tier;
+}
+/** The switch, or `null` when this repo is not pruned. */
+export function readPruneMarker(rootDir) {
+    const file = path.join(rootDir, PRUNE_MARKER_PATH);
+    if (!existsSync(file))
+        return null;
+    let data;
+    try {
+        data = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new CLIError(`\`${PRUNE_MARKER_PATH}\` no es JSON válido; corrígelo o vuelve a correr \`factory prune prepare\`.`);
+    }
+    const marker = data;
+    if (typeof marker?.tier !== 'string' || typeof marker.at !== 'string') {
+        throw new CLIError(`\`${PRUNE_MARKER_PATH}\` debe tener la forma { "tier": "<nombre>", "at": "<fecha ISO>" }.`);
+    }
+    return { tier: marker.tier, at: marker.at };
+}
+export function writePruneMarker(rootDir, marker) {
+    mkdirSync(path.join(rootDir, TIMEKAST_DIR), { recursive: true });
+    writeFileSync(path.join(rootDir, PRUNE_MARKER_PATH), `${JSON.stringify(marker, null, 2)}\n`, 'utf8');
+}

package/dist/lib/prune-update.js

@@ -0,0 +1,78 @@
+/**
+ * `factory update` in a pruned repo (`factory prune`): keep the tier's `.gitignore` block in
+ * step with the kit, and compute what the brain commit must untrack and publish.
+ *
+ * Everything here is gated on `.timekast/prune.json`. Without it `planPruneMaintenance`
+ * returns `null` and the update behaves exactly as in a repo that was never pruned.
+ *
+ * The registry is read from the STAGED tarball, not from the repo: the tier the release ships
+ * is the one the commit has to honor, including a path that moved from restricted to shared.
+ * Such a path is in the `unchanged` bucket when its content did not change, so the update
+ * would never write it — it sits on the member's disk, untracked, and would never be
+ * published unless this module names it.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { GITIGNORE_FILE, MANAGED_BLOCK_START } from './constants.js';
+import { syncManagedBlock } from './gitattributes.js';
+import { trackedFiles } from './prune-git.js';
+import { LEGACY_COLLAB_START, PRUNE_MARKER_PATH, PRUNE_TIERS_PATH, getTier, isRestricted, readPruneMarker, readPruneTiers, renderGitignoreBlock, stripLegacyCollabBlock, } from './prune-tiers.js';
+/** Does `.gitignore` carry a prune block (the kit's or CMLL's hand-written one)? */
+function hasPruneBlock(rootDir) {
+    const file = path.join(rootDir, GITIGNORE_FILE);
+    if (!existsSync(file))
+        return false;
+    const content = readFileSync(file, 'utf8');
+    return (content.includes(LEGACY_COLLAB_START) ||
+        content.split('\n').some((l) => l.startsWith(MANAGED_BLOCK_START) && l.includes('prune tier')));
+}
+/**
+ * Regenerate the block and plan the commit's untrack/publish sets. Best-effort like the other
+ * dotfile syncs: a problem is reported and the update (already applied) stands.
+ *
+ * @param manifestPaths every path of the NEW manifest (what the kit ships now).
+ */
+export async function planPruneMaintenance(rootDir, stagedDir, manifestPaths) {
+    let marker;
+    try {
+        marker = readPruneMarker(rootDir);
+    }
+    catch (err) {
+        console.warn(`Aviso: ${err instanceof Error ? err.message : String(err)} No mantuve el tier.`);
+        return null;
+    }
+    if (!marker) {
+        if (hasPruneBlock(rootDir)) {
+            console.warn(`Aviso: \`${GITIGNORE_FILE}\` tiene el bloque de un repo compartido pero falta ` +
+                `\`${PRUNE_MARKER_PATH}\`, así que el guard del pre-commit está apagado. ` +
+                'Si el repo se comparte con colaboradores, corre `factory prune prepare`.');
+        }
+        return null;
+    }
+    try {
+        const source = existsSync(path.join(stagedDir, PRUNE_TIERS_PATH)) ? stagedDir : rootDir;
+        const tier = getTier(readPruneTiers(source), marker.tier);
+        const gitignorePath = path.join(rootDir, GITIGNORE_FILE);
+        if (existsSync(gitignorePath)) {
+            const stripped = stripLegacyCollabBlock(readFileSync(gitignorePath, 'utf8'));
+            if (stripped.removed)
+                writeFileSync(gitignorePath, stripped.content, 'utf8');
+        }
+        const { action } = syncManagedBlock(rootDir, renderGitignoreBlock(marker.tier, tier), GITIGNORE_FILE);
+        if (action !== 'unchanged') {
+            console.log(`✔ \`${GITIGNORE_FILE}\`: bloque del tier \`${marker.tier}\` sincronizado.`);
+        }
+        const tracked = new Set(await trackedFiles(rootDir));
+        return {
+            tierName: marker.tier,
+            tier,
+            untrack: [...tracked].filter((p) => isRestricted(tier, p)),
+            publish: manifestPaths.filter((p) => !tracked.has(p) && !isRestricted(tier, p) && existsSync(path.join(rootDir, p))),
+        };
+    }
+    catch (err) {
+        console.warn(`Aviso: no se pudo mantener el tier \`${marker.tier}\` ` +
+            `(${err instanceof Error ? err.message : String(err)}); el cerebro se instaló igual.`);
+        return null;
+    }
+}

package/dist/lib/prune-vercel.js

@@ -0,0 +1,137 @@
+/**
+ * `factory prune vercel` — reconnect the Vercel project to the repo the cut created.
+ *
+ * Vercel binds a project to GitHub's NUMERIC repo id, and a rename keeps the id: after
+ * `prune cutover` the project still deploys from `<repo>-legacy`. Re-linking to the new
+ * repo takes an unlink + link (`DELETE` then `POST /v9/projects/{id}/link`); the project,
+ * its env vars, domains and deployments stay.
+ *
+ * Order is the safety argument:
+ *   1. read the current link and the new repo's id — already linked → nothing to do;
+ *   2. without `--confirm`, print the plan and stop;
+ *   3. unlink → link → READ the link back and require the new repo's id.
+ * A failure between 1 and 3 leaves the project unlinked (it serves its last deployment, it
+ * just stops deploying on push); a re-run with `--confirm` links it, since step 1 sees no link.
+ * Never triggers a deployment.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { CLIError } from './cli-error.js';
+import { readDestroyTarget } from './provision-state.js';
+import { getGitLink, linkGitRepo, unlinkGitRepo, } from './vercel-env.js';
+/** GitHub's numeric id of `repo`, read with the member's `gh` session. */
+async function githubRepoId(repo, deps) {
+    const r = await deps.gh(['api', `repos/${repo}`, '--jq', '.id']);
+    const id = Number(r.stdout.trim());
+    if (r.exitCode !== 0 || !Number.isInteger(id)) {
+        throw new CLIError(`No pude leer \`${repo}\` en GitHub: ${r.stderr || 'respuesta sin id'}`);
+    }
+    return id;
+}
+export async function pruneVercelRelink(input, deps) {
+    const { projectId, teamId, token } = input;
+    const api = deps.fetchImpl ? { fetchImpl: deps.fetchImpl } : {};
+    const targetId = await githubRepoId(input.repo, deps);
+    const from = await getGitLink(projectId, token, teamId, api);
+    if (from?.repoId === targetId)
+        return { status: 'already-linked', link: from };
+    if (!input.confirm)
+        return { status: 'plan', from, to: input.repo };
+    if (from)
+        await unlinkGitRepo(projectId, token, teamId, api);
+    try {
+        await linkGitRepo(projectId, token, teamId, input.repo, api);
+    }
+    catch (error) {
+        const why = error instanceof Error ? error.message : String(error);
+        throw new CLIError(`Desconecté el proyecto de Vercel${from ? ` de \`${from.repo}\`` : ''} pero no pude conectarlo a ` +
+            `\`${input.repo}\`: ${why}\nEl proyecto sigue sirviendo su último deploy; sólo dejó de desplegar ` +
+            'con cada push. Corrige la causa (p. ej. la GitHub App de Vercel sin acceso al repo nuevo) y ' +
+            'vuelve a correr `factory prune vercel --confirm`: ve que no hay vínculo y sólo conecta.');
+    }
+    const to = await getGitLink(projectId, token, teamId, api);
+    if (to?.repoId !== targetId) {
+        throw new CLIError(`Vercel aceptó el vínculo pero al releerlo apunta a ${to ? `\`${to.repo}\`` : 'ningún repo'}, no a ` +
+            `\`${input.repo}\`. Revísalo en el dashboard (Settings → Git) antes de seguir.`);
+    }
+    return { status: 'relinked', from, to };
+}
+/**
+ * The project and team to relink: flags first, then `.vercel/project.json`, then the provision
+ * state (`.timekast/provision.json`). Never guessed from a project listing.
+ */
+export function resolveVercelProject(rootDir, flags) {
+    let projectId = flags.project;
+    let teamId = flags.team;
+    const linkFile = path.join(rootDir, '.vercel', 'project.json');
+    if ((!projectId || !teamId) && existsSync(linkFile)) {
+        try {
+            const link = JSON.parse(readFileSync(linkFile, 'utf8'));
+            projectId ??= link.projectId;
+            teamId ??= link.teamId ?? link.orgId;
+        }
+        catch {
+            // unreadable → fall through to the provision state
+        }
+    }
+    if (!projectId || !teamId) {
+        const target = readDestroyTarget(rootDir);
+        projectId ??= target?.vercelProjectId ?? undefined;
+        teamId ??= target?.scope ?? undefined;
+    }
+    if (!projectId || !teamId) {
+        throw new CLIError('No encontré el proyecto de Vercel de este repo (ni en `.vercel/project.json` ni en ' +
+            '`.timekast/provision.json`). Pásalo: `factory prune vercel --project=prj_… --team=team_…`.');
+    }
+    return { projectId, teamId };
+}
+/**
+ * Which branches deploy on push in a pruned repo: only `main` and `develop`. Vercel deploys
+ * when ANY matching rule is `true`, so `**: false` turns off every other branch — a
+ * collaborator's branch (an author without a Vercel seat) never starts a deployment Vercel
+ * would block. `**`, not `*`: minimatch's `*` does not cross a `/` (`feat/login`).
+ */
+export const BRANCH_DEPLOY_RULE = {
+    '**': false,
+    main: true,
+    develop: true,
+};
+export const VERCEL_JSON = 'vercel.json';
+/** Whether `vercel.json` already carries {@link BRANCH_DEPLOY_RULE}. `null` without the file. */
+export function hasBranchDeployRule(rootDir) {
+    const file = path.join(rootDir, VERCEL_JSON);
+    if (!existsSync(file))
+        return null;
+    const config = JSON.parse(readFileSync(file, 'utf8'));
+    const rules = config.git?.deploymentEnabled;
+    if (!rules || typeof rules !== 'object')
+        return false;
+    return Object.entries(BRANCH_DEPLOY_RULE).every(([branch, on]) => rules[branch] === on);
+}
+/**
+ * Write {@link BRANCH_DEPLOY_RULE} into `vercel.json`, keeping every other key and any other
+ * branch rule. A repo without `vercel.json` (not on Vercel) is left alone.
+ *
+ * @throws {CLIError} when `vercel.json` is not valid JSON.
+ */
+export function ensureBranchDeployRule(rootDir) {
+    const file = path.join(rootDir, VERCEL_JSON);
+    if (!existsSync(file))
+        return 'no-vercel-json';
+    let config;
+    try {
+        config = JSON.parse(readFileSync(file, 'utf8'));
+    }
+    catch {
+        throw new CLIError(`\`${VERCEL_JSON}\` no es JSON válido; corrígelo y vuelve a correr.`);
+    }
+    if (hasBranchDeployRule(rootDir))
+        return 'present';
+    const git = (config.git && typeof config.git === 'object' ? config.git : {});
+    const prior = git.deploymentEnabled && typeof git.deploymentEnabled === 'object'
+        ? git.deploymentEnabled
+        : {};
+    config.git = { ...git, deploymentEnabled: { ...prior, ...BRANCH_DEPLOY_RULE } };
+    writeFileSync(file, `${JSON.stringify(config, null, 2)}\n`);
+    return 'added';
+}

package/dist/lib/rail.js

@@ -53,8 +53,10 @@ import { VAULT_CONFIG } from './vault-config.js';
 export const RAIL_ENV = 'main';
 /** Name of the vault CLI binary on PATH. */
 export const INFISICAL_BIN = 'infisical';
-/** How to install the vault CLI (`fx-secrets-vault §3`). */
-export const INFISICAL_INSTALL_HINT = 'brew install infisical';
+/** How to install the vault CLI, per platform, already code-quoted (`sk-vault §2`). */
+export const INFISICAL_INSTALL_HINT = '`brew install infisical` (Windows: `winget install --id infisical.infisical` y abre una terminal nueva)';
+/** How to upgrade the vault CLI, per platform, already code-quoted. */
+export const INFISICAL_UPGRADE_HINT = '`brew upgrade infisical` o `winget upgrade --id infisical.infisical`';
 /** Default time budget (ms) for one rail read — a dead network or a stuck prompt must not hang. */
 export const RAIL_READ_TIMEOUT_MS = 30_000;
 /** Grace (ms) between SIGTERM and SIGKILL once the timeout fires. */
@@ -135,7 +137,7 @@ export class RailUnrecognizedError extends RailError {
 export class RailNotInstalledError extends RailError {
     constructor(config = VAULT_CONFIG) {
         super('not-installed', 'El CLI de la bóveda (`infisical`) no está instalado o no está en el PATH.\n' +
-            `Instálalo con \`${INFISICAL_INSTALL_HINT}\` y entra con \`${loginCommand(config)}\`.`);
+            `Instálalo con ${INFISICAL_INSTALL_HINT} y entra con \`${loginCommand(config)}\`.`);
         this.name = 'RailNotInstalledError';
         Object.setPrototypeOf(this, new.target.prototype);
     }

package/dist/lib/railway-api.js

@@ -744,6 +744,9 @@ export function createRailwayClient(deps = {}) {
                 if (typeof settings[key] === 'string')
                     input[key] = settings[key];
             }
+            if (typeof settings.drainingSeconds === 'number') {
+                input.drainingSeconds = settings.drainingSeconds;
+            }
             if (Object.keys(input).length === 0)
                 return false;
             await call('serviceInstanceUpdate', { serviceId, environmentId, input }, `ajustar el servicio \`${serviceId}\` en su entorno`);