@everystack/cli 0.2.36 → 0.2.37

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/cli",
-  "version": "0.2.36",
+  "version": "0.2.37",
   "description": "CLI and OTA updates for Expo apps on everystack",
   "license": "AGPL-3.0-only",
   "publishConfig": {

package/src/cli/observability.ts

@@ -10,6 +10,8 @@
  *   {prefix}/events/YYYY/MM/DD/HH/{ts}-{id}.ndjson   (one JSON LogEvent per line)
  * Hour partitions are UTC. Canonical writer + query semantics:
  *   packages/logging/src/service/s3-log-storage.ts
+ * A contract test fails loudly if the writer drifts from what this reader assumes:
+ *   packages/logging/__tests__/service/cli-reader-format.contract.test.ts
  *
  * We read the format rather than import the class because @everystack/logging
  * pulls React Native (admin/ui) through its peer graph — wrong for a standalone CLI.

package/src/storage/filesystem.ts

@@ -32,6 +32,32 @@ export class FilesystemStorageAdapter implements StorageAdapter {
     }
   }
 
+  async getWithEtag(key: string): Promise<{ data: Buffer; contentType: string; etag: string } | null> {
+    const obj = await this.get(key);
+    if (!obj) return null;
+    const meta = await this.head(key);
+    return { ...obj, etag: meta?.etag ?? '' };
+  }
+
+  /**
+   * Best-effort CAS for the filesystem backend (dev). Not atomic across
+   * processes, but dev runs single-process — the precondition check + write is
+   * a faithful stand-in for S3's conditional PUT.
+   */
+  async putConditional(
+    key: string,
+    data: Buffer | Uint8Array,
+    opts: { ifMatch?: string; ifNoneMatch?: string },
+    contentType?: string,
+  ): Promise<{ etag: string } | null> {
+    const current = await this.head(key);
+    if (opts.ifNoneMatch === '*' && current) return null; // must not exist
+    if (opts.ifMatch && (!current || current.etag !== opts.ifMatch)) return null; // must match
+    await this.put(key, data, contentType);
+    const after = await this.head(key);
+    return { etag: after?.etag ?? '' };
+  }
+
   async exists(key: string): Promise<boolean> {
     const meta = await this.head(key);
     return meta !== null;

package/src/storage/index.ts

@@ -1,6 +1,24 @@
 export interface StorageAdapter {
   put(key: string, data: Buffer | Uint8Array, contentType?: string): Promise<void>;
   get(key: string): Promise<{ data: Buffer; contentType: string } | null>;
+  /**
+   * Read body + ETag in one request — the atomic basis for compare-and-swap.
+   * Optional: only the CAS-using paths (DB-free alert rules/state) need it; both
+   * shipped adapters (S3, filesystem) implement it.
+   */
+  getWithEtag?(key: string): Promise<{ data: Buffer; contentType: string; etag: string } | null>;
+  /**
+   * Conditional write (compare-and-swap). `ifNoneMatch: '*'` succeeds only if the
+   * object does not yet exist; `ifMatch: <etag>` only if the current ETag matches.
+   * Returns the new ETag, or null when the precondition failed (another writer won).
+   * Optional (see getWithEtag); both shipped adapters implement it.
+   */
+  putConditional?(
+    key: string,
+    data: Buffer | Uint8Array,
+    opts: { ifMatch?: string; ifNoneMatch?: string },
+    contentType?: string,
+  ): Promise<{ etag: string } | null>;
   exists(key: string): Promise<boolean>;
   /** Returns object metadata (ETag, size), or null if not found. */
   head(key: string): Promise<{ etag: string; size?: number } | null>;

package/src/storage/s3.ts

@@ -55,6 +55,57 @@ export class S3StorageAdapter implements StorageAdapter {
     }
   }
 
+  async getWithEtag(key: string): Promise<{ data: Buffer; contentType: string; etag: string } | null> {
+    const { GetObjectCommand } = await import('@aws-sdk/client-s3');
+    const client = await this.getClient();
+    try {
+      const response = await client.send(new GetObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+      }));
+      const bodyBytes = await response.Body!.transformToByteArray();
+      return {
+        data: Buffer.from(bodyBytes),
+        contentType: response.ContentType || 'application/octet-stream',
+        etag: response.ETag || '',
+      };
+    } catch (err: any) {
+      if (err.name === 'NoSuchKey' || err.$metadata?.httpStatusCode === 404) {
+        return null;
+      }
+      throw err;
+    }
+  }
+
+  async putConditional(
+    key: string,
+    data: Buffer | Uint8Array,
+    opts: { ifMatch?: string; ifNoneMatch?: string },
+    contentType?: string,
+  ): Promise<{ etag: string } | null> {
+    const { PutObjectCommand } = await import('@aws-sdk/client-s3');
+    const client = await this.getClient();
+    try {
+      const response = await client.send(new PutObjectCommand({
+        Bucket: this.bucket,
+        Key: key,
+        Body: data,
+        ContentType: contentType || 'application/octet-stream',
+        ...(opts.ifMatch ? { IfMatch: opts.ifMatch } : {}),
+        ...(opts.ifNoneMatch ? { IfNoneMatch: opts.ifNoneMatch } : {}),
+      }));
+      return { etag: response.ETag || '' };
+    } catch (err: any) {
+      // 412 PreconditionFailed (If-Match/If-None-Match) or 409 conditional conflict
+      // both mean another writer raced us — not an error, just "you didn't win".
+      const status = err.$metadata?.httpStatusCode;
+      if (err.name === 'PreconditionFailed' || err.name === 'ConditionalRequestConflict' || status === 412 || status === 409) {
+        return null;
+      }
+      throw err;
+    }
+  }
+
   async exists(key: string): Promise<boolean> {
     const meta = await this.head(key);
     return meta !== null;