@rikalabs/akter-cli 0.1.0-alpha.3 → 0.1.0-alpha.5

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## 0.1.0-alpha.5 (2026-10-09)
+
+- Releases with the matching alpha.5 framework, which adds the supported four-session `Database.postgres({ url, preset: "low-connection" })` preset. CLI behavior and the bundled `@rikalabs/akter-cli/cloud-api` contract are unchanged from alpha.4.
+
+## 0.1.0-alpha.4 (2026-10-09)
+
+- **Breaking cloud contract:** every environment uses customer Postgres through `DATABASE_URL`. `Environment.database`, when reported, is `{ source: "customer", state: "missing" | "reachable" | "unreachable", latency, latencyWarning, runnerCap }`. Latency is nullable p50 milliseconds; runner cap is a nullable integer. The managed source and provisioning, ready, read-only and failed states are removed.
+- **Breaking billing contract:** base subscription plus compute unit-hours only. Removes storage allowances, caps, overage prices, meters, samples, per-project storage usage and managed database features. `QuotaExceeded.cap` is now `compute`, `connections` or `spend`; storage is no longer a quota. All types remain derived from Effect schemas at `@rikalabs/akter-cli/cloud-api`.
+- `akter env list` prints names and update times without a `managed` marker. After a deployment reaches `live`, `akter deploy` confirms success and reads the database report, printing its latency warning and non-null runner cap, including zero, only for the completed rollout. A p50 above 5 ms warns without refusing the deployment; unknown measurements stay unknown. Failed or superseded diagnostic reads warn without changing the successful exit status.
+- `akter deploy` keeps following a rollout through a brief control-plane outage. Transport failures, typed `Unavailable` (503) answers without a known `reason` and unreadable 5xx answers such as a proxy's 502 are retried with the delays `logs --follow` uses (1, 2, 4, then 8 seconds), and six consecutive failed reads stop it as before. Refusals, including an ended session, are never retried.
+- The cloud API contract's `Authentication` middleware declares `Unavailable` (503) alongside `Unauthorized` and `Forbidden`, so every endpoint, including `/api/me`, decodes a session-store outage as a typed `Unavailable`. `akter whoami` then reports a temporary outage (exit 1) instead of an unreachable control plane (exit 2), and never asks you to log in again. This is additive for `/cloud-api` consumers; a server may now fail authentication with `Unavailable`.
+
 ## 0.1.0-alpha.3 (2026-10-08)
 
 The first CLI release, versioned with `@rikalabs/akter` on the `alpha` and `latest` dist-tags. This includes the unpublished alpha.2 draft and the final launch contract.

package/dist/cloud-api/auth.d.ts

@@ -1,6 +1,6 @@
 import { Context, Schema } from "effect";
 import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api";
-import { Forbidden, Unauthorized } from "./errors.ts";
+import { Forbidden, Unauthorized, Unavailable } from "./errors.ts";
 /** The cookie that carries the Better Auth session token over plain HTTP. */
 export declare const sessionCookieName = "better-auth.session_token";
 /** The same cookie as Better Auth names it when served over HTTPS. */
@@ -46,7 +46,7 @@ export declare class CurrentIdentity extends CurrentIdentity_base {
 declare const Authentication_base: HttpApiMiddleware.ServiceClass<Authentication, "@akter/cloud-api/Authentication", {
     requires: never;
     provides: CurrentIdentity;
-    error: readonly [typeof Unauthorized, typeof Forbidden];
+    error: readonly [typeof Unauthorized, typeof Forbidden, typeof Unavailable];
     clientError: never;
     requiredForClient: false;
     security: {
@@ -60,14 +60,17 @@ declare const Authentication_base: HttpApiMiddleware.ServiceClass<Authentication
     readonly secureSession: HttpApiSecurity.ApiKey;
     readonly apiKey: HttpApiSecurity.ApiKey;
     readonly bearer: HttpApiSecurity.Http;
-}, CurrentIdentity, readonly [typeof Unauthorized, typeof Forbidden], never>>;
+}, CurrentIdentity, readonly [typeof Unauthorized, typeof Forbidden, typeof Unavailable], never>>;
 /**
  * Resolves who is calling. The server implements one handler per security
  * scheme and fails `Unauthorized` when a scheme's credential is missing or
  * invalid; the first scheme that succeeds provides `CurrentIdentity`. A cookie
  * browser client sends credentials automatically, so no client implementation
  * is required. `bearer` carries the session token a CLI receives from Better
- * Auth's device authorization grant.
+ * Auth's device authorization grant. A credential the server cannot check
+ * because its session store is down fails `Unavailable`, never
+ * `Unauthorized`, so every endpoint's client can tell an outage from a
+ * session that ended.
  *
  * @effect-expect-leaking HttpServerRequest | ParsedSearchParams | RouteContext
  */

package/dist/cloud-api/billing.d.ts

@@ -48,16 +48,13 @@ export type SpendLimit = typeof SpendLimit.Type;
  * reported, discriminated by `cap`. `limit` is null when the cap does not
  * apply. `atCap` means usage has reached the limit; `refusing` means the edge
  * would refuse the next new command, or for `connections` the next new
- * connection, or for `storage` that the organization's managed databases are
- * read-only: writes fail and reads still work. `reason` is `unbound` when the
+ * connection. `reason` is `unbound` when the
  * edge refuses everything because the organization has no billing account;
  * such caps have no limit.
  *
  * `limit` and `used` are cents for `spend`, open connections for
  * `connections`, compute unit-hours used in the current billing period for
- * `compute`, and decimal gigabytes for `storage`: the organization's pooled
- * managed database storage, where `used` is the latest pooled sample. A
- * database the customer brings never counts toward it.
+ * `compute`. Customer database storage is not metered, capped or billed.
  */
 export declare const CapState: Schema.Struct<{
     readonly limit: Schema.NullOr<Schema.Finite>;
@@ -65,7 +62,7 @@ export declare const CapState: Schema.Struct<{
     readonly atCap: Schema.Boolean;
     readonly refusing: Schema.Boolean;
     readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-    readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+    readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
 }>;
 export type CapState = typeof CapState.Type;
 /**
@@ -104,7 +101,7 @@ export declare const BillingSummary: Schema.Struct<{
         readonly atCap: Schema.Boolean;
         readonly refusing: Schema.Boolean;
         readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
     }>>>;
 }>;
 export type BillingSummary = typeof BillingSummary.Type;
@@ -141,11 +138,10 @@ export declare const HostedSession: Schema.Struct<{
 export type HostedSession = typeof HostedSession.Type;
 /**
  * What a plan offers, derived from the pricing configuration: billed compute
- * overage, a hard compute cap, billed storage overage, a hard storage cap, a
- * database the customer brings, a dedicated database, and a paid subscription
- * bought through checkout.
+ * overage, a hard compute cap, customer Postgres on every plan, and a paid
+ * subscription bought through checkout.
  */
-export declare const PlanFeature: Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>;
+export declare const PlanFeature: Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>;
 export type PlanFeature = typeof PlanFeature.Type;
 /**
  * One tier of the pricing configuration. `allowances.computeUnitHours` is the
@@ -154,12 +150,7 @@ export type PlanFeature = typeof PlanFeature.Type;
  * `overage.computeCentsPerUnitHour`). A machine size's hour bills the compute
  * unit-hours `PlanCatalog.computeSizes` gives it.
  *
- * `allowances.storageGb` is the managed database storage included in the
- * plan, in decimal gigabytes, pooled across the organization's managed
- * environment databases. `allowances.storageGbCap` is its hard stop, past
- * which those databases are read-only, and is null when overage is billed
- * instead at `overage.storageCentsPerGbMonth`. A provisional tier's prices
- * are not yet published.
+ * A provisional tier's prices are not yet published.
  */
 export declare const CatalogPlan: Schema.Struct<{
     readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
@@ -169,15 +160,12 @@ export declare const CatalogPlan: Schema.Struct<{
     readonly allowances: Schema.Struct<{
         readonly computeUnitHours: Schema.Finite;
         readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
-        readonly storageGb: Schema.Finite;
-        readonly storageGbCap: Schema.NullOr<Schema.Finite>;
         readonly concurrentConnections: Schema.Int;
     }>;
     readonly overage: Schema.Struct<{
         readonly computeCentsPerUnitHour: Schema.Finite;
-        readonly storageCentsPerGbMonth: Schema.Finite;
     }>;
-    readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+    readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>>;
     readonly provisional: Schema.Boolean;
 }>;
 export type CatalogPlan = typeof CatalogPlan.Type;
@@ -207,15 +195,12 @@ export declare const PlanCatalog: Schema.Struct<{
         readonly allowances: Schema.Struct<{
             readonly computeUnitHours: Schema.Finite;
             readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
-            readonly storageGb: Schema.Finite;
-            readonly storageGbCap: Schema.NullOr<Schema.Finite>;
             readonly concurrentConnections: Schema.Int;
         }>;
         readonly overage: Schema.Struct<{
             readonly computeCentsPerUnitHour: Schema.Finite;
-            readonly storageCentsPerGbMonth: Schema.Finite;
         }>;
-        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>>;
         readonly provisional: Schema.Boolean;
     }>>;
     readonly computeSizes: Schema.$Array<Schema.Struct<{
@@ -230,13 +215,12 @@ export type PlanCatalog = typeof PlanCatalog.Type;
 /**
  * `runnerHours` is measured in compute unit-hours (see `ComputeUsage`), not
  * machine hours; raw machine hours are reported per machine size in
- * `ComputeUsage.machineHours`. `storageGb` is the average pooled managed
- * database storage over the period in decimal gigabytes, billed per GB-month.
+ * `ComputeUsage.machineHours`.
  */
-export declare const UsageMeterName: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+export declare const UsageMeterName: Schema.Literal<"runnerHours">;
 export type UsageMeterName = typeof UsageMeterName.Type;
 export declare const UsageMeter: Schema.Struct<{
-    readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+    readonly meter: Schema.Literal<"runnerHours">;
     readonly used: Schema.Finite;
     readonly included: Schema.Finite;
     readonly overage: Schema.Finite;
@@ -246,12 +230,10 @@ export type UsageMeter = typeof UsageMeter.Type;
 /**
  * The published rules usage is priced by, sent with every usage report.
  * `computeCentsPerUnitHour` prices compute unit-hours beyond the plan's
- * allowance and `storageCentsPerGbMonth` prices managed database storage
- * beyond it; each is 0 where the plan bills no overage.
+ * allowance and is 0 where the plan bills no overage.
  */
 export declare const UsagePricing: Schema.Struct<{
     readonly computeCentsPerUnitHour: Schema.Finite;
-    readonly storageCentsPerGbMonth: Schema.Finite;
     readonly provisional: Schema.optionalKey<Schema.Boolean>;
 }>;
 export type UsagePricing = typeof UsagePricing.Type;
@@ -269,42 +251,27 @@ export declare const ComputeUsage: Schema.Struct<{
     readonly computeUnitHours: Schema.Finite;
 }>;
 export type ComputeUsage = typeof ComputeUsage.Type;
-/**
- * The organization's latest pooled managed database storage: the sum of the
- * sampled bytes of its managed environment databases, and when it was
- * sampled. A database the customer brings is excluded.
- */
-export declare const StorageSample: Schema.Struct<{
-    readonly bytes: Schema.Finite;
-    readonly sampledAt: Schema.DateTimeUtc;
-}>;
-export type StorageSample = typeof StorageSample.Type;
 /**
  * `caps` describe now whatever `period` is reported. A project's
  * `computeUnitHours` is its compute for the period and `compute` breaks it
- * down by environment and machine size; its `storageGbMonths` is its managed
- * databases' storage for the period.
+ * down by environment and machine size.
  */
 export declare const Usage: Schema.Struct<{
     readonly period: Schema.String;
     readonly meters: Schema.$Array<Schema.Struct<{
-        readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+        readonly meter: Schema.Literal<"runnerHours">;
         readonly used: Schema.Finite;
         readonly included: Schema.Finite;
         readonly overage: Schema.Finite;
         readonly overageCostCents: Schema.Finite;
     }>>;
-    readonly latestStorageSample: Schema.NullOr<Schema.Struct<{
-        readonly bytes: Schema.Finite;
-        readonly sampledAt: Schema.DateTimeUtc;
-    }>>;
     readonly caps: Schema.$Array<Schema.Struct<{
         readonly limit: Schema.NullOr<Schema.Finite>;
         readonly used: Schema.Finite;
         readonly atCap: Schema.Boolean;
         readonly refusing: Schema.Boolean;
         readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
     }>>;
     readonly byProject: Schema.$Array<Schema.Struct<{
         readonly projectId: Schema.brand<Schema.String, "ProjectId">;
@@ -318,12 +285,10 @@ export declare const Usage: Schema.Struct<{
             readonly machineHours: Schema.Finite;
             readonly computeUnitHours: Schema.Finite;
         }>>;
-        readonly storageGbMonths: Schema.Finite;
         readonly estimatedCostCents: Schema.Finite;
     }>>;
     readonly pricing: Schema.Struct<{
         readonly computeCentsPerUnitHour: Schema.Finite;
-        readonly storageCentsPerGbMonth: Schema.Finite;
         readonly provisional: Schema.optionalKey<Schema.Boolean>;
     }>;
 }>;