@labelbox/recursion-cli 0.0.48 → 0.0.49

package/README.md

@@ -30,22 +30,13 @@ live CLI reflects it as soon as the backend deploys. The CLI is re-released only
 its own engine code changes. When the server is reachable, the manifest is
 revalidated on every run via a conditional fetch (ETag / `If-None-Match`) and cached
 per base-url under `~/.cache/recursion/`. When the server is unreachable, the CLI may
-use the last locally validated copy so commands remain available offline. If only the
-previous `~/.cache/rl-gym/` entry exists, the CLI validates and uses it immediately,
-then adopts it into the Recursion cache non-destructively. The
-old entry is retained unchanged for rollback; new server responses are written only
-to the Recursion cache.
-
-Legacy adoption uses atomic create-if-absent publication: a validated copy is
-hard-linked from a unique same-directory temporary file, so it never replaces a
-canonical entry created concurrently. A valid concurrent canonical entry wins; an
-invalid one is left untouched while that invocation uses the validated legacy value
-in memory. Validated fresh HTTP `200` responses use atomic same-directory rename and
-therefore retain last-network-writer behavior. Replacement preserves an existing
-file's POSIX mode bits, but deliberately publishes a new inode and does not preserve
-its ACLs or extended attributes. Both paths require parent-directory write/search
-permission; if unavailable, the CLI keeps using the validated in-memory result and
-never falls back to a partial direct write.
+use the last locally validated copy so commands remain available offline. Validated
+fresh HTTP `200` responses use atomic same-directory rename and therefore retain
+last-network-writer behavior. Replacement preserves an existing file's POSIX mode
+bits, but deliberately publishes a new inode and does not preserve its ACLs or
+extended attributes. Publication requires parent-directory write/search permission;
+if unavailable, the CLI keeps using the validated in-memory result and never falls
+back to a partial direct write.
 
 ### Docs browse surfaces
 

package/dist/manifest.js

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { closeSync, fchmodSync, linkSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync, } from 'node:fs';
+import { closeSync, fchmodSync, mkdirSync, openSync, readFileSync, renameSync, statSync, unlinkSync, writeSync, } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import process from 'node:process';
@@ -308,9 +308,6 @@ export function hostSlug(baseUrl) {
 function canonicalCachePathFor(baseUrl) {
     return join(homedir(), '.cache', 'recursion', `${hostSlug(baseUrl)}.json`);
 }
-function legacyCachePathFor(baseUrl) {
-    return join(homedir(), '.cache', 'rl-gym', `${hostSlug(baseUrl)}.json`);
-}
 function readCache(path) {
     let raw;
     try {
@@ -339,14 +336,13 @@ function readCache(path) {
         return {
             etag: parsed.data.etag,
             manifest: parseManifest(parsed.data.manifest, 'the cache'),
-            raw,
         };
     }
     catch {
         return undefined;
     }
 }
-const CACHE_TEMP_PREFIX = '.rlc-';
+const CACHE_TEMP_PREFIX = '.recursion-cli-';
 function uniqueCacheTempPath(directory) {
     return join(directory, `${CACHE_TEMP_PREFIX}${process.pid.toString()}-${randomUUID()}.tmp`);
 }
@@ -357,9 +353,7 @@ function uniqueCacheTempPath(directory) {
  * including a partial write or close failure — triggers best-effort pathname cleanup.
  * Descriptor ownership is cleared before the single close attempt: retrying a numeric
  * descriptor could close an unrelated resource if the operating system reused it.
- * Publication happens only after close succeeds. The caller reports whether it
- * transferred the inode (rename) or retained it (hard-link adoption), which determines
- * final cleanup ownership.
+ * Publication happens only after close succeeds and transfers the temp inode.
  */
 function publishFromOwnedTemp(path, raw, prepare, publish) {
     let tempPath;
@@ -383,8 +377,8 @@ function publishFromOwnedTemp(path, raw, prepare, publish) {
         const descriptorToClose = descriptor;
         descriptor = undefined;
         closeSync(descriptorToClose);
-        if (publish(tempPath) === 'transferred')
-            ownsTemp = false;
+        publish(tempPath);
+        ownsTemp = false;
     }
     catch {
         // Cache persistence is a bandwidth optimization. The caller already has a
@@ -428,38 +422,8 @@ function replaceCacheAtomically(path, raw) {
             fchmodSync(descriptor, destination.mode & 0o7777);
     }, (tempPath) => {
         renameSync(tempPath, path);
-        return 'transferred';
-    });
-}
-/**
- * Publish validated legacy bytes only if the canonical destination is absent.
- *
- * The hard link is the no-replace commit point: unlike rename, it fails if any
- * concurrent invocation has created the destination. Best-effort temporary-path
- * cleanup is attempted afterward, while a winning canonical path is never overwritten.
- */
-function publishCacheIfAbsent(path, raw) {
-    publishFromOwnedTemp(path, raw, () => { }, (tempPath) => {
-        linkSync(tempPath, path);
-        return 'retained';
     });
 }
-/** Prefer canonical cache; otherwise adopt a validated legacy file without mutating it. */
-function selectCache(baseUrl) {
-    const canonicalPath = canonicalCachePathFor(baseUrl);
-    const canonical = readCache(canonicalPath);
-    if (canonical !== undefined)
-        return canonical;
-    const legacy = readCache(legacyCachePathFor(baseUrl));
-    if (legacy === undefined)
-        return undefined;
-    // Copy the validated bytes exactly. Hard-link publication cannot replace a
-    // canonical file that appears after the reads above. Re-read afterward: prefer a
-    // valid concurrent winner, but leave an invalid winner untouched and keep using
-    // the already-validated legacy value in memory.
-    publishCacheIfAbsent(canonicalPath, legacy.raw);
-    return readCache(canonicalPath) ?? legacy;
-}
 // Every `recursion` invocation gates on this fetch, so it must be bounded: a server that
 // accepts the connection but never responds (a hung gateway, a stalled captive
 // portal) would otherwise hang the CLI forever. A timeout makes `fetch` reject, so
@@ -478,7 +442,7 @@ const MANIFEST_FETCH_TIMEOUT_MS = 30_000;
 export async function fetchManifest(baseUrl, apiKey) {
     const url = supportUrl(baseUrl, '/cli/manifest');
     const canonicalCachePath = canonicalCachePathFor(baseUrl);
-    const cached = selectCache(baseUrl);
+    const cached = readCache(canonicalCachePath);
     let res;
     try {
         res = await fetch(url, {

package/dist/resolve.d.ts

@@ -2,11 +2,7 @@
 export declare function flagValue(argv: string[], name: string): string | undefined;
 /** `--api-key` wins over `LABELBOX_API_KEY`; undefined when neither is set. */
 export declare function resolveApiKey(argv: string[]): string | undefined;
-/**
- * The base URL from the environment: the current `RECURSION_BASE_URL`, else the
- * deprecated `RL_GYM_BASE_URL`. Shared by `resolveBaseUrl` here and the `recursion skills`
- * resolver so the precedence lives — and is tested — in one place.
- */
+/** The canonical base URL from the environment. */
 export declare function envBaseUrl(): string | undefined;
-/** `--base-url` wins over `RECURSION_BASE_URL` (or the deprecated `RL_GYM_BASE_URL`), falling back to the production host. */
+/** `--base-url` wins over `RECURSION_BASE_URL`, falling back to the production host. */
 export declare function resolveBaseUrl(argv: string[]): string;

package/dist/resolve.js

@@ -28,16 +28,11 @@ export function resolveApiKey(argv) {
     const { LABELBOX_API_KEY: envApiKey } = process.env;
     return flagValue(argv, 'api-key') ?? envApiKey;
 }
-/**
- * The base URL from the environment: the current `RECURSION_BASE_URL`, else the
- * deprecated `RL_GYM_BASE_URL`. Shared by `resolveBaseUrl` here and the `recursion skills`
- * resolver so the precedence lives — and is tested — in one place.
- */
+/** The canonical base URL from the environment. */
 export function envBaseUrl() {
-    const { RECURSION_BASE_URL: recursionBaseUrl, RL_GYM_BASE_URL: legacyBaseUrl } = process.env;
-    return recursionBaseUrl ?? legacyBaseUrl;
+    return process.env['RECURSION_BASE_URL'];
 }
-/** `--base-url` wins over `RECURSION_BASE_URL` (or the deprecated `RL_GYM_BASE_URL`), falling back to the production host. */
+/** `--base-url` wins over `RECURSION_BASE_URL`, falling back to the production host. */
 export function resolveBaseUrl(argv) {
     return flagValue(argv, 'base-url') ?? envBaseUrl() ?? DEFAULT_BASE_URL;
 }

package/dist/skills.js

@@ -61,9 +61,8 @@ const SkillSummarySchema = z.object({
 /** Resolve the base URL for the skills endpoints (never throws — they are public). */
 function resolveBaseUrl(program) {
     const { baseUrl } = program.opts();
-    // --base-url wins over the env vars; none set → the production proxy. Shares
-    // envBaseUrl() with resolve.ts so the RECURSION_BASE_URL / RL_GYM_BASE_URL
-    // precedence lives in one tested place.
+    // --base-url wins over RECURSION_BASE_URL; neither set → the production proxy.
+    // Shares envBaseUrl() with resolve.ts so the precedence lives in one tested place.
     return baseUrl ?? envBaseUrl() ?? DEFAULT_BASE_URL;
 }
 /** The configured API key (--api-key or LABELBOX_API_KEY), if any. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@labelbox/recursion-cli",
-  "version": "0.0.48",
+  "version": "0.0.49",
   "type": "module",
   "repository": {
     "type": "git",