@rikalabs/akter-cli 0.0.0-stage → 0.1.0-alpha.4

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

@@ -0,0 +1,44 @@
+import { Schema } from "effect";
+/** Limits apply to both recent reads and each resumed long poll. */
+export declare const MAX_LOG_LINES = 200;
+export declare const MAX_LOG_TEXT_BYTES = 4096;
+export declare const MAX_LOG_WINDOW_SECONDS = 3600;
+export declare const MAX_LOG_WAIT_SECONDS = 20;
+/** An opaque position, bound to the authorized resource, never a provider app selector. */
+export declare const LogCursor: Schema.String;
+export declare const LogLimit: Schema.Int;
+export declare const LogWait: Schema.Int;
+export declare const logQuery: {
+    since: Schema.optional<Schema.DateTimeUtc>;
+    limit: Schema.optional<Schema.Int>;
+    cursor: Schema.optional<Schema.String>;
+    wait: Schema.optional<Schema.Int>;
+};
+/** Customer runner output only; build output and control-plane logs use different surfaces. */
+export declare const RunnerLogLine: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly deploymentId: Schema.brand<Schema.String, "DeploymentId">;
+    readonly runnerId: Schema.String;
+    readonly at: Schema.DateTimeUtc;
+    /** Fly merges output streams; unknown preserves that limitation instead of inventing a stream. */
+    readonly stream: Schema.Literals<readonly ["stdout", "stderr", "unknown"]>;
+    readonly text: Schema.String;
+    readonly clipped: Schema.Boolean;
+}>;
+export type RunnerLogLine = typeof RunnerLogLine.Type;
+/** More means another page can be read immediately; clipping is reported independently on each line. */
+export declare const RunnerLogPage: Schema.Struct<{
+    readonly lines: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly deploymentId: Schema.brand<Schema.String, "DeploymentId">;
+        readonly runnerId: Schema.String;
+        readonly at: Schema.DateTimeUtc;
+        /** Fly merges output streams; unknown preserves that limitation instead of inventing a stream. */
+        readonly stream: Schema.Literals<readonly ["stdout", "stderr", "unknown"]>;
+        readonly text: Schema.String;
+        readonly clipped: Schema.Boolean;
+    }>>;
+    readonly cursor: Schema.String;
+    readonly more: Schema.Boolean;
+}>;
+export type RunnerLogPage = typeof RunnerLogPage.Type;

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

@@ -0,0 +1,82 @@
+import { Schema } from "effect";
+export declare const UserId: Schema.brand<Schema.String, "UserId">;
+export type UserId = typeof UserId.Type;
+export declare const OrganizationId: Schema.brand<Schema.String, "OrganizationId">;
+export type OrganizationId = typeof OrganizationId.Type;
+export declare const MemberId: Schema.brand<Schema.String, "MemberId">;
+export type MemberId = typeof MemberId.Type;
+export declare const InvitationId: Schema.brand<Schema.String, "InvitationId">;
+export type InvitationId = typeof InvitationId.Type;
+export declare const ApiKeyId: Schema.brand<Schema.String, "ApiKeyId">;
+export type ApiKeyId = typeof ApiKeyId.Type;
+export declare const ProjectId: Schema.brand<Schema.String, "ProjectId">;
+export type ProjectId = typeof ProjectId.Type;
+export declare const DeploymentId: Schema.brand<Schema.String, "DeploymentId">;
+export type DeploymentId = typeof DeploymentId.Type;
+export declare const DomainId: Schema.brand<Schema.String, "DomainId">;
+export type DomainId = typeof DomainId.Type;
+export declare const DeadLetterId: Schema.brand<Schema.String, "DeadLetterId">;
+export type DeadLetterId = typeof DeadLetterId.Type;
+export declare const InvoiceId: Schema.brand<Schema.String, "InvoiceId">;
+export type InvoiceId = typeof InvoiceId.Type;
+/** An opaque environment identifier assigned by the control plane. */
+export declare const EnvironmentId: Schema.brand<Schema.String, "EnvironmentId">;
+export type EnvironmentId = typeof EnvironmentId.Type;
+/** Lowercase letters, digits and inner hyphens, 1 to 40 characters. */
+export declare const Slug: Schema.brand<Schema.String, "Slug">;
+export type Slug = typeof Slug.Type;
+/** A display name: 1 to 100 characters with no leading or trailing blanks. */
+export declare const Name: Schema.brand<Schema.String, "Name">;
+export type Name = typeof Name.Type;
+export declare const Email: Schema.brand<Schema.String, "Email">;
+export type Email = typeof Email.Type;
+export declare const NonNegativeInt: Schema.Int;
+export type NonNegativeInt = typeof NonNegativeInt.Type;
+export declare const NonNegative: Schema.Finite;
+export type NonNegative = typeof NonNegative.Type;
+/** A UTC instant; the JSON codec reads and writes ISO 8601 strings. */
+export declare const Timestamp: Schema.DateTimeUtc;
+/** A UTC calendar day written `YYYY-MM-DD`. */
+export declare const CalendarDay: Schema.String;
+export type CalendarDay = typeof CalendarDay.Type;
+/** A billing period written `YYYY-MM`. */
+export declare const BillingPeriod: Schema.String;
+export type BillingPeriod = typeof BillingPeriod.Type;
+export declare const Role: Schema.Literals<readonly ["owner", "admin", "member", "viewer"]>;
+export type Role = typeof Role.Type;
+/** The roles an invitation may grant; ownership is never granted by invitation. */
+export declare const InviteRole: Schema.Literals<readonly ["admin", "member", "viewer"]>;
+export type InviteRole = typeof InviteRole.Type;
+export declare const EnvironmentName: Schema.Literals<readonly ["production", "staging", "dev"]>;
+export type EnvironmentName = typeof EnvironmentName.Type;
+/** The launch regions; a new region is a contract change. */
+export declare const RegionId: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+export type RegionId = typeof RegionId.Type;
+/** A commit SHA, abbreviated or full. */
+export declare const CommitSha: Schema.String;
+export type CommitSha = typeof CommitSha.Type;
+/** An actor address written `Type/key`. */
+export declare const ActorAddress: Schema.String;
+export type ActorAddress = typeof ActorAddress.Type;
+/** Who performed an action: a person or an organization API key. */
+export declare const ActorReference: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["user", "api-key"]>;
+    readonly id: Schema.String;
+    readonly name: Schema.NullOr<Schema.String>;
+}>;
+export type ActorReference = typeof ActorReference.Type;
+export declare const SeriesPoint: Schema.Struct<{
+    readonly at: Schema.DateTimeUtc;
+    readonly value: Schema.Finite;
+}>;
+export type SeriesPoint = typeof SeriesPoint.Type;
+/** Query fields shared by every paged list; spread them into an endpoint's `query`. */
+export declare const pageQuery: {
+    limit: Schema.optional<Schema.Int>;
+    cursor: Schema.optional<Schema.String>;
+};
+/** A page of `item`; `nextCursor` is null on the last page. */
+export declare const Page: <const Item extends Schema.Top>(item: Item) => Schema.Struct<{
+    readonly items: Schema.$Array<Item>;
+    readonly nextCursor: Schema.NullOr<Schema.String>;
+}>;

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

@@ -0,0 +1,189 @@
+import { Schema } from "effect";
+export declare const ProjectStatus: Schema.Literals<readonly ["empty", "live", "deploying", "failed"]>;
+export type ProjectStatus = typeof ProjectStatus.Type;
+export declare const Region: Schema.Struct<{
+    readonly id: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+    readonly city: Schema.String;
+}>;
+export type Region = typeof Region.Type;
+export declare const Project: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "ProjectId">;
+    readonly organizationId: Schema.brand<Schema.String, "OrganizationId">;
+    readonly name: Schema.String;
+    readonly slug: Schema.brand<Schema.String, "Slug">;
+    readonly status: Schema.Literals<readonly ["empty", "live", "deploying", "failed"]>;
+    readonly homeRegion: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+    readonly createdAt: Schema.DateTimeUtc;
+}>;
+export type Project = typeof Project.Type;
+export declare const CreateProject: Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "Name">;
+    readonly slug: Schema.brand<Schema.String, "Slug">;
+    readonly homeRegion: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+}>;
+export type CreateProject = typeof CreateProject.Type;
+export declare const UpdateProject: Schema.Struct<{
+    readonly name: Schema.optional<Schema.brand<Schema.String, "Name">>;
+    readonly slug: Schema.optional<Schema.brand<Schema.String, "Slug">>;
+}>;
+export type UpdateProject = typeof UpdateProject.Type;
+/**
+ * Every environment uses the customer's Postgres through `DATABASE_URL`.
+ * `latency` is the deploy probe's p50 in milliseconds from the runner region,
+ * null when unmeasured. Above 5 ms, `latencyWarning` warns without refusing.
+ * `runnerCap` is floor((max_connections - in_use - 10) / 9), null when unknown;
+ * a non-positive cap means no runner fits the available connection budget.
+ * The status carries no URL or URL-derived field.
+ */
+export declare const Environment: Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly projectId: Schema.brand<Schema.String, "ProjectId">;
+    readonly currentDeploymentId: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
+    readonly database: Schema.optionalKey<Schema.Struct<{
+        readonly source: Schema.Literal<"customer">;
+        readonly state: Schema.Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: Schema.NullOr<Schema.Finite>;
+        readonly latencyWarning: Schema.Boolean;
+        readonly runnerCap: Schema.NullOr<Schema.Int>;
+    }>>;
+}>;
+export type Environment = typeof Environment.Type;
+export declare const CreateEnvironment: Schema.Struct<{
+    readonly name: Schema.Literals<readonly ["production", "staging", "dev"]>;
+}>;
+export type CreateEnvironment = typeof CreateEnvironment.Type;
+/** An environment variable as readable: its name and provenance, never its value or any part of it. */
+export declare const EnvVariable: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly usedBy: Schema.$Array<Schema.String>;
+    readonly updatedAt: Schema.DateTimeUtc;
+    readonly updatedBy: Schema.NullOr<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["user", "api-key"]>;
+        readonly id: Schema.String;
+        readonly name: Schema.NullOr<Schema.String>;
+    }>>;
+}>;
+export type EnvVariable = typeof EnvVariable.Type;
+export declare const EnvVariableName: Schema.String;
+export type EnvVariableName = typeof EnvVariableName.Type;
+/** The write-only value of a variable, at most 64 KiB. */
+export declare const SetEnvVariable: Schema.Struct<{
+    readonly value: Schema.String;
+}>;
+export type SetEnvVariable = typeof SetEnvVariable.Type;
+/** The text of a `.env` file, at most 1 MiB. */
+export declare const ImportEnvVariables: Schema.Struct<{
+    readonly content: Schema.String;
+}>;
+export type ImportEnvVariables = typeof ImportEnvVariables.Type;
+export declare const ImportEnvVariablesResult: Schema.Struct<{
+    readonly created: Schema.$Array<Schema.String>;
+    readonly updated: Schema.$Array<Schema.String>;
+}>;
+export type ImportEnvVariablesResult = typeof ImportEnvVariablesResult.Type;
+export declare const DomainStatus: Schema.Literals<readonly ["pending", "verifying", "active"]>;
+export type DomainStatus = typeof DomainStatus.Type;
+export declare const DnsRecord: Schema.Struct<{
+    readonly type: Schema.Literals<readonly ["A", "AAAA", "CNAME", "TXT"]>;
+    readonly name: Schema.String;
+    readonly value: Schema.String;
+}>;
+export type DnsRecord = typeof DnsRecord.Type;
+export declare const Hostname: Schema.String;
+export type Hostname = typeof Hostname.Type;
+export declare const Domain: Schema.Struct<{
+    readonly id: Schema.brand<Schema.String, "DomainId">;
+    readonly hostname: Schema.String;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+    readonly status: Schema.Literals<readonly ["pending", "verifying", "active"]>;
+    readonly dnsRecords: Schema.$Array<Schema.Struct<{
+        readonly type: Schema.Literals<readonly ["A", "AAAA", "CNAME", "TXT"]>;
+        readonly name: Schema.String;
+        readonly value: Schema.String;
+    }>>;
+    readonly createdAt: Schema.DateTimeUtc;
+}>;
+export type Domain = typeof Domain.Type;
+export declare const AddDomain: Schema.Struct<{
+    readonly hostname: Schema.String;
+    readonly environment: Schema.Literals<readonly ["production", "staging", "dev"]>;
+}>;
+export type AddDomain = typeof AddDomain.Type;
+export declare const OwnedTable: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly actor: Schema.String;
+    readonly rows: Schema.Int;
+    readonly sizeBytes: Schema.Int;
+    readonly region: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+}>;
+export type OwnedTable = typeof OwnedTable.Type;
+/** One region of an environment: its database, load and largest owned tables. */
+export declare const ProjectRegion: Schema.Struct<{
+    readonly region: Schema.Struct<{
+        readonly id: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+        readonly city: Schema.String;
+    }>;
+    readonly home: Schema.Boolean;
+    readonly tenantCount: Schema.Int;
+    readonly database: Schema.Struct<{
+        readonly version: Schema.String;
+        readonly sizeBytes: Schema.Int;
+    }>;
+    readonly storage: Schema.Struct<{
+        readonly usedBytes: Schema.Int;
+        readonly limitBytes: Schema.Int;
+    }>;
+    readonly cpuPercent: Schema.Finite;
+    readonly connections: Schema.Struct<{
+        readonly used: Schema.Int;
+        readonly limit: Schema.Int;
+    }>;
+    readonly runners: Schema.Int;
+    readonly largestTables: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly actor: Schema.String;
+        readonly rows: Schema.Int;
+        readonly sizeBytes: Schema.Int;
+        readonly region: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+    }>>;
+}>;
+export type ProjectRegion = typeof ProjectRegion.Type;
+export declare const AddRegion: Schema.Struct<{
+    readonly region: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+}>;
+export type AddRegion = typeof AddRegion.Type;
+export declare const SetHomeRegion: Schema.Struct<{
+    readonly region: Schema.Literals<readonly ["us-east-1", "us-west-2"]>;
+}>;
+export type SetHomeRegion = typeof SetHomeRegion.Type;
+export declare const ProjectEndpoints: Schema.Struct<{
+    readonly httpBaseUrl: Schema.String;
+    readonly webSocketUrl: Schema.String;
+    readonly openApiPath: Schema.String;
+    readonly mcpPath: Schema.String;
+}>;
+export type ProjectEndpoints = typeof ProjectEndpoints.Type;
+export declare const IntegrationKind: Schema.Literals<readonly ["github", "slack", "datadog", "opentelemetry", "pagerduty"]>;
+export type IntegrationKind = typeof IntegrationKind.Type;
+export declare const Integration: Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["github", "slack", "datadog", "opentelemetry", "pagerduty"]>;
+    readonly status: Schema.Literals<readonly ["connected", "disconnected", "error"]>;
+    readonly label: Schema.NullOr<Schema.String>;
+    readonly connectedAt: Schema.NullOr<Schema.DateTimeUtc>;
+}>;
+export type Integration = typeof Integration.Type;
+/** Write-only settings for key-based integrations; OAuth integrations send none and follow the returned URL. */
+export declare const ConnectIntegration: Schema.Struct<{
+    readonly settings: Schema.optional<Schema.$Record<Schema.String, Schema.String>>;
+}>;
+export type ConnectIntegration = typeof ConnectIntegration.Type;
+export declare const IntegrationConnection: Schema.Struct<{
+    readonly redirectUrl: Schema.NullOr<Schema.String>;
+    readonly integration: Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["github", "slack", "datadog", "opentelemetry", "pagerduty"]>;
+        readonly status: Schema.Literals<readonly ["connected", "disconnected", "error"]>;
+        readonly label: Schema.NullOr<Schema.String>;
+        readonly connectedAt: Schema.NullOr<Schema.DateTimeUtc>;
+    }>;
+}>;
+export type IntegrationConnection = typeof IntegrationConnection.Type;