Skip to content

Prepare release artifacts from tags - #97

Merged
IlyaasK merged 1 commit into
hypeship/v1-release-artifactsfrom
hypeship/v1-release-prepare
Jul 30, 2026
Merged

Prepare release artifacts from tags#97
IlyaasK merged 1 commit into
hypeship/v1-release-artifactsfrom
hypeship/v1-release-prepare

Conversation

@IlyaasK

@IlyaasK IlyaasK commented Jul 11, 2026

Copy link
Copy Markdown
Collaborator

Summary

This PR adds the preparation half of the provider release path. A stable
vMAJOR.MINOR.PATCH tag triggers a workflow that rejects missing licensing,
non-public visibility, and commits outside main before building.

The workflow uses pinned GoReleaser OSS v2.17.0 to build unsigned, unpublished
artifacts. A shared verifier checks the exact 13-platform archive contract,
platform-correct provider binary names, the versioned Registry manifest,
checksum coverage, and checksum contents before retaining the artifacts for
seven days.

Why this is v1 work

The first public provider release needs a reproducible artifact handoff before
signing and publication. This PR has read-only repository permissions and
cannot access signing secrets or create a GitHub Release.

Provider surface

  • Resource and data-source behavior is unchanged.
  • Kernel API and SDK behavior is unchanged.
  • Terraform state and import behavior are unchanged.
  • No sensitive provider values enter the release workflow.

Verification

  • gofmt -l cmd internal
  • go test -short -timeout=2m ./...
  • go vet ./...
  • terraform fmt -check -recursive examples
  • bash scripts/check-docs.sh
  • bash scripts/check-markdown-links.sh
  • bash scripts/check-examples.sh
  • bash scripts/check-registry-manifest.sh
  • goreleaser check
  • shellcheck scripts/check-release-artifacts.sh scripts/check-release-snapshot.sh
  • Actionlint v1.7.12
  • GoReleaser OSS v2.17.0 non-snapshot build from temporary local stable tag
    v99.99.99
  • Verified all 13 archives, platform-correct binaries, the Registry manifest,
    exact checksum coverage, and SHA-256 contents
  • Negative checks for mismatched versions, missing or modified manifests, and
    malformed checksum files

Live acceptance tests were not rerun because this PR does not change provider
behavior. The complete acceptance matrix remains a manual pre-tag gate.

Deferred release gates

Signed checksum publication and GitHub Release creation remain in the next
focused release PR. Before the first public tag, the stack must be merged to
main, the complete acceptance matrix must pass on the release commit, and
repository visibility must be public.

Issues #24 and #25 remain outside this PR.


Note

Low Risk
Changes are limited to release CI scripts and documentation; the workflow uses read-only contents permissions and does not touch provider runtime code or secrets.

Overview
Adds a tag-driven release preparation workflow that runs on v* pushes and builds unsigned, unpublished Terraform Registry assets without creating a GitHub Release or signing checksums.

Before GoReleaser runs, the job enforces stable semver tags, a non-empty LICENSE, public repository visibility, and that the tagged commit is reachable from origin/main. It pins GoReleaser v2.17.0, sets GORELEASER_CURRENT_TAG to the pushed tag, runs release --clean --skip=publish,sign, copies the registry manifest into dist, and runs shared verification. Verified zips, manifest, and SHA256SUMS are uploaded as a 7-day workflow artifact.

Release contract checks move into scripts/check-release-artifacts.sh (13 platforms, archive contents, manifest match, checksum coverage and sha256sum -c). check-release-snapshot.sh now only runs a snapshot build and delegates to that script. docs/release.md documents the workflow and notes that GPG signing and registry publication stay a separate step.

Reviewed by Cursor Bugbot for commit 6a40866. Bugbot is set up for automated code reviews on this repo. Configure here.

@IlyaasK
IlyaasK marked this pull request as ready for review July 11, 2026 20:35
@IlyaasK
IlyaasK requested review from Sayan- and tnsardesai July 11, 2026 20:35
Comment thread .github/workflows/release.yml
@IlyaasK
IlyaasK removed request for Sayan- and tnsardesai July 13, 2026 13:25
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-artifacts branch from 623d863 to 647dc9d Compare July 13, 2026 13:36
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch from 01ac93e to a62a99d Compare July 13, 2026 13:36
Comment thread .github/workflows/release.yml Outdated
"terraform-provider-kernel_${version}_windows_arm64.zip"
)"
actual_assets="$(awk 'NF == 2 { print $2 }' "$checksum" | sort)"
diff -u <(printf '%s\n' "$expected_assets") <(printf '%s\n' "$actual_assets")

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Asset list compare not order-safe

Low Severity

The artifact contract check sorts only actual_assets before diff, while expected_assets stays in hand-written order. The check is meant to assert set equality, but it actually requires the printf list to stay lexicographically sorted. Reordering or inserting a platform name out of sort order makes a valid release fail verification.

Fix in Cursor Fix in Web

Reviewed by Cursor Bugbot for commit a62a99d. Configure here.

Copy link
Copy Markdown
Collaborator Author

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Fixed in the rebuilt branch. The shared artifact verifier now sorts both the generated expected filename set and the checksum-derived actual filename set before comparing them. I also exercised the verifier with the checksum lines reversed; the valid release still passes.

@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch from a62a99d to b85cf78 Compare July 13, 2026 14:32
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-artifacts branch from 400811b to 4d802d1 Compare July 13, 2026 15:39
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch from b85cf78 to 18cfeea Compare July 13, 2026 15:39
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch 2 times, most recently from a89c140 to ef813b3 Compare July 21, 2026 14:46
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-artifacts branch from 1163a2f to f8ef464 Compare July 21, 2026 18:10
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch from ef813b3 to 888edd0 Compare July 21, 2026 18:10
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-artifacts branch from f8ef464 to 15de1e0 Compare July 21, 2026 19:51
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch 2 times, most recently from 094fc64 to efa2797 Compare July 21, 2026 20:15

@cursor cursor Bot left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Cursor Bugbot has reviewed your changes using high effort and found 1 potential issue.

There are 2 total unresolved issues (including 1 from previous review).

Fix All in Cursor

❌ Bugbot Autofix is OFF. To automatically fix reported issues with cloud agents, enable autofix in the Cursor dashboard.

Reviewed by Cursor Bugbot for commit efa2797. Configure here.

Comment thread .github/workflows/release.yml Outdated
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-artifacts branch 3 times, most recently from c76e86a to 59a6014 Compare July 28, 2026 15:25
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch from efa2797 to 17d0c8a Compare July 28, 2026 21:16
@linear-code

linear-code Bot commented Jul 28, 2026

Copy link
Copy Markdown
KERNEL-1559 Terraform provider v1: production-ready durable Kernel configuration

tldr

Ship v1 of the Kernel Terraform provider so a user can describe their durable Kernel platform config — project, browser infra, profiles, proxies, extensions, deployments, and carefully-scoped API keys — entirely in Terraform. Durable desired-state only; runtime/session activity is explicitly out of scope. Start from the merged v0 state, produce a scope-audit + plan before coding, and ship in small per-resource PRs.

Current groundwork already done

API-contract prerequisites and the security hardening surfaced while auditing them are in flight as draft PRs on kernel/kernel. v0 of the provider is merged; provider resource code should begin after these land and one batched Stainless SDK regen + kernel-go-sdk bump.

API contract prep (draft PRs):

  • #2599 — reject API key self-deletion (a key can't delete the key authenticating the request)
  • #2600 — document name uniqueness + list query match semantics
  • #2602 — browser pool reads echo resolved profile_id / extension_ids (stable references for state)
  • #2603 — make the browser pool OpenAPI contract truthful (PATCH clear sentinels, validation bounds, defaults)
  • #2604 — exact-match name= filter on list endpoints (stacked on #2600)
  • #2607 — store + return a sha256 checksum for uploaded extensions (drift detection)
  • #2608 — persist + echo deployment source identity (repo/ref/path/checksum; write-only source becomes importable)
  • #2624 — document env var redaction on deployment/app reads (values redacted for API-key auth) — mergeable

Security fixes surfaced during the audit (draft PRs):

  • #2629 — getSession cross-project scope: a project-scoped key could reach sibling projects' live browser sessions (fs/process/computer/CDP/curl) — now 404
  • #2632 — block project-scoped keys from org-level mutations (org limits, credential providers)
  • #2633 — enforce project scope on the projects endpoints: scoped keys can read + rename their own project only; create/delete/status/limits stay org-key-only

Open decisions before the late phases:

  • API key resource state design (plaintext-once, rotation, self-delete) — phase 8 gated on acceptance
  • #24 force_destroy and #25 tfplugingen codegen dispositions (see below)
  • One batched SDK regen sequences all of the above into the provider

v1 product definition

v1 should manage durable Kernel platform configuration.

core v1 resources:

  • kernel_project
  • kernel_browser_pool
  • kernel_profile
  • kernel_proxy
  • kernel_extension
  • kernel_deployment
  • kernel_api_key, if safe state semantics are designed and accepted

core v1 data sources:

  • kernel_project
  • kernel_browser_pool
  • kernel_profile
  • kernel_proxy
  • kernel_extension
  • kernel_deployment
  • kernel_app
  • kernel_api_key metadata lookup, masked only

important adjustment:

  • kernel_app should probably be a data source, not a resource, unless the API exposes apps as first-class mutable durable objects separate from deployments.
  • app invocations are runtime and must not be Terraform resources.
  • app logs are observability/runtime and must not be Terraform resources.
  • standalone kernel_secret should not be added unless Kernel exposes a dedicated durable secrets API with safe write-only or masked-read semantics.
  • app env vars belong on kernel_deployment; mark them sensitive.

explicit non-goals

do not add Terraform resources for temporary/runtime activity:

  • browser sessions
  • acquire/release
  • browser pool flush
  • app invocation
  • invocation status updates
  • invocation browser cleanup
  • logs
  • screenshots
  • live view
  • telemetry streams
  • runtime counters
  • leased browser state
  • session recovery
  • managed runtime browser updates

do not add these unless explicitly approved later:

  • billing resources
  • org membership resources
  • audit log resources
  • managed-auth credentials/connections
  • standalone secret store resources without a real Kernel secret API
  • internal-only admin controls
  • dashboard-only or integration-specific objects such as Vercel resources

do not manually edit generated files.

do not include private Slack, Linear, customer, or internal discussion context in code, comments, commits, branches, docs, or PR bodies.

required first step: v1 scope audit

before writing code, inspect:

  • current openapi/stainless/sdk surface in kernel/kernel
  • current v0 provider architecture in kernel/terraform-provider-kernel
  • current docs in kernel/docs
  • open github issues in kernel/terraform-provider-kernel
  • docs/concerns.md
  • v0 acceptance tests and release docs

produce a concise v1 implementation plan before coding.

the plan must classify every candidate resource as:

  • in v1 core
  • v1 optional/late
  • v1 non-goal
  • blocked on API contract

github issues to resolve in v1

handle these explicitly:

#24 force_destroy

evaluate whether force_destroy belongs in v1.

default position:

  • keep it out unless there is a concrete user workflow that needs Terraform to delete in-use browser pools.
  • if added:
    • default must be false
    • behavior must be opt-in
    • docs must explain that it can terminate live browser work
    • tests must cover default false and true-when-set
    • state preservation must avoid perpetual drift
    • architecture docs must record the exception

#25 tfplugingen-framework codegen

evaluate before adding many new schemas.

preferred v1 approach:

  • if codegen is accepted, do it early.
  • generate only mechanical Terraform shape:
    • schema structs
    • model structs
    • nested attribute helpers
    • basic validators from durable API contract
  • keep behavior handwritten:
    • CRUD
    • import
    • update/clear semantics
    • exact lookup behavior
    • sensitive handling
    • browser pool flatten/expand decisions
    • chrome policy normalization
  • add a CI drift check if generated files are introduced.
  • never generate runtime/session APIs into Terraform.

if codegen is not implemented, document why in docs/concerns.md or architecture docs and close/defer the issue accordingly.

architecture requirements

Terraform manages durable desired state only.

all resources must obey:

  • create/read/update/delete where supported
  • import where possible
  • exact lookup data sources
  • stable project scoping
  • no runtime fields in desired state
  • sensitive values marked sensitive
  • no secret values logged
  • delete semantics documented
  • update-vs-replace semantics explicit
  • clear/null/empty semantics explicit
  • acceptance tests for real API behavior

project scoping rules:

  • provider-level project_id remains default.
  • resource-level project_id overrides provider default where supported.
  • changing project_id should force replacement unless the API explicitly supports moving the resource.
  • unscoped/org-wide resources must be clearly modeled.

runtime fields:

  • omit if not useful for Terraform.
  • computed-only if they help users inspect state and do not cause drift.
  • never use volatile runtime fields to drive diffs.

sensitive fields:

  • api_key, proxy credentials, deployment env vars, GitHub tokens, and created API key plaintext must be sensitive.
  • avoid reading secret values back into state.
  • if API returns secrets in read responses, document the state risk and mark fields sensitive.
  • prefer masked metadata on reads.

resource design expectations

kernel_project

include if API supports project lifecycle.

likely fields:

  • id
  • name
  • durable limits if API treats them as project-owned config
  • created/updated timestamps computed-only if useful

requirements:

  • exact lookup by id/name
  • import by id
  • test create/update/delete/import
  • decide whether project limits are nested fields or separate kernel_project_limits

kernel_profile

include durable profile ownership.

requirements:

  • create/read/update/delete/import if API supports it
  • exact lookup by id/name
  • omit runtime usage fields such as last_used_at unless computed-only
  • profile archive upload/download only if API semantics are stable
  • no browser-session save behavior as Terraform action

kernel_proxy

include durable proxy config if API supports user-owned proxy records.

requirements:

  • credentials sensitive
  • health/check status computed-only or omitted
  • changing immutable connection fields should replace
  • exact lookup by id/name
  • import support

kernel_extension

include durable extension records.

requirements:

  • support uploaded extension/package if API supports it
  • support Chrome Web Store/reference flow only if API treats it as durable config
  • use file hash/source hash to detect package changes
  • browser pool owns extension_ids ordering
  • exact lookup by id/name
  • import support

kernel_browser_pool

harden v0.

requirements:

  • preserve durable-only model
  • expand acceptance coverage
  • verify update/clear behavior for profile/proxy/extensions/chrome_policy/start_url/viewport
  • resolve or explicitly defer force_destroy
  • no runtime/session state

kernel_deployment

include for app platform v1.

model deployments, not invocations.

likely fields:

  • id
  • version
  • source block for GitHub deploys
  • file/archive path only if Terraform can produce stable reproducible diffs
  • entrypoint_rel_path
  • region
  • force
  • env_vars, sensitive
  • app_name/actions/status computed from API
  • deployment status computed-only

requirements:

  • create/read/delete
  • update probably replace unless API supports mutation
  • import by deployment id
  • do not stream deployment events as Terraform state
  • do not model logs
  • do not invoke apps
  • private GitHub token sensitive and preferably not persisted after create if API does not store it

kernel_app

default to data source only.

requirements:

  • exact lookup by app name/version
  • expose deployment id, version, actions, region, maybe env var keys but not secret values if avoidable
  • no app resource unless API exposes app-level create/update/delete separate from deployment lifecycle

kernel_api_key

include late in v1 only after state design is accepted.

requirements:

  • create/list/get/update/delete/rotate are API-supported.
  • plaintext key is returned once on create/rotate.
  • Terraform resource must expose plaintext key as sensitive computed only when created/rotated.
  • reads must use masked metadata.
  • import must import metadata only, never recover plaintext.
  • rotation must be explicit:
    • either a separate action-like pattern is avoided
    • or rotation is triggered by an explicit rotate_on_change/keeper-like field
  • support project-scoped keys.
  • do not let the provider accidentally destroy the API key it is currently using unless clearly documented.

api/sdk contract requirements

before implementing each resource, verify:

  • exact create/read/update/delete endpoints exist
  • SDK exposes the endpoint or provider can safely wrap generated client
  • read response includes stable ids
  • list pagination is documented
  • exact lookup can distinguish zero and multiple matches
  • update clear semantics are documented:
    • omitted
    • null
    • empty string
    • empty array
    • empty object
  • server defaults are documented
  • validation bounds match API behavior
  • sensitive fields are masked or safely handled
  • import behavior is possible
  • project scoping behavior is clear
  • delete behavior is safe and idempotent enough for Terraform

if any gap blocks implementation, log it in docs/concerns.md and do not guess.

preferred PR phases

prefer small PRs. split anything large.

phase 0: v1 architecture and scope PR

  • update architecture docs for v1 target surface
  • update docs/concerns.md
  • classify open issues
  • decide codegen approach
  • no large implementation yet

phase 1: codegen/drift decision PR

  • implement tfplugingen workflow only if accepted
  • add CI drift check if generated files exist
  • otherwise document why v1 remains handwritten

phase 2: project resource PR

  • kernel_project
  • project data-source hardening
  • import
  • acceptance tests

phase 3: durable browser support PRs
split by resource:

  • kernel_profile
  • kernel_proxy
  • kernel_extension
  • browser pool hardening

phase 4: apps/deployments PRs
split into:

  • kernel_deployment
  • kernel_app data source
  • env var sensitive handling
  • examples

phase 5: api keys PR
only after sensitive state design is accepted:

  • kernel_api_key
  • kernel_api_key data source
  • rotation/import semantics
  • docs warning

phase 6: v1 release readiness PR

  • docs
  • examples
  • acceptance matrix
  • changelog
  • migration notes from v0
  • registry/release automation
  • final v1 checklist

implementation process

for each PR:

  1. read the relevant API docs/openapi/sdk/code.
  2. write a small resource design note in the PR body or docs.
  3. implement the smallest coherent vertical slice.
  4. add focused unit tests.
  5. add acceptance tests behind explicit env gates.
  6. update generated docs.
  7. update examples.
  8. run review gates.
  9. open a draft PR.

do not implement multiple resources in one PR unless one is a tiny shared helper needed by the other.

testing requirements

always run:

  • gofmt -l cmd internal
  • go test -short -timeout=2m ./...
  • go vet ./...

when terraform is available:

  • terraform fmt -check -recursive examples
  • bash scripts/check-docs.sh
  • any example validation script

for each resource:

  • schema tests
  • expand/flatten tests
  • CRUD behavior tests with fake client
  • import tests
  • project-scope tests
  • sensitive field tests
  • acceptance test

acceptance tests:

  • opt-in only
  • unique names
  • cleanup registered early
  • no runtime/session operations unless testing deployment creation itself
  • no force deletion unless explicitly testing accepted force_destroy

follow fast-test discipline:

  • focused unit tests first
  • integration tests only where unit tests cannot prove behavior
  • docker/start-heavy tests only where necessary
  • keep setup fast
  • use eblog.fly.dev's test fast / docker fast / start fast guidance as the testing philosophy

required review gates

run these gates for every PR before push.

gate 1: deslop

  • inspect git diff <base>...HEAD.
  • remove ai-looking comments, needless defensive checks, dead code, style drift, and casts that avoid real type work.
  • preserve comments that document real invariants.

gate 2: auto incremental self-pr review

  • review the diff in small logical chunks.
  • do this autonomously.
  • maintain an internal action-item list:
    • correctness
    • terraform semantics
    • state drift
    • sensitive data
    • project scoping
    • import behavior
    • acceptance coverage
    • docs/examples
    • scope creep
  • fix accepted findings before the next gate.

gate 3: autoreview

  • run structured autoreview against the branch/pr diff.
  • verify every finding in code.
  • fix accepted/actionable findings.
  • reject speculative or over-broad findings explicitly.

gate 4: final agreement pass

  • review gates run linearly, not in parallel.
  • each review sees the fixed result from prior reviews.
  • if reviewers disagree, choose the simpler safer design that preserves Terraform semantics and durable-only scope.
  • final summary must state:
    • findings fixed
    • findings rejected and why
    • remaining risks
    • final clean review result

subagent coordination rules

implementation agents:

  • use only when work can be split by resource or file ownership.
  • assign disjoint write sets.
  • tell agents they are not alone in the codebase.
  • avoid parallel edits to shared provider registration or shared helpers unless one agent owns that layer.

review agents:

  • never run in parallel.
  • run linearly:
    1. deslop reviewer
    2. incremental self-reviewer
    3. autoreview reviewer
    4. final agreement pass
  • do not run expensive review panels unless explicitly requested.

PR requirements

every PR must include:

  • summary
  • resource/data-source scope
  • API contract notes
  • Terraform state semantics
  • sensitive field handling
  • import behavior
  • tests run
  • acceptance status
  • known deferred concerns
  • whether the PR resolves any GitHub issues

open draft PRs by default.

save branch and PR artifacts after pushing/opening.

v1 done criteria

v1 is complete when:

  • all core durable resources are implemented or explicitly deferred with documented API blockers.
  • every resource has import support or a documented reason it cannot.
  • every resource has unit tests and acceptance tests.
  • generated docs are current.
  • examples cover common production use.
  • sensitive values are handled deliberately.
  • API key semantics are safe or API keys are deferred.
  • deployment env vars are sensitive and documented.
  • app invocations/logs/runtime browser operations are not Terraform resources.
  • #24 is resolved by implementation or explicit documented rejection.
  • #25 is resolved by implementation or explicit documented rejection.
  • ci and release workflows are production-ready.
  • v0 users have clear migration notes.

required PR breakdown

keep PRs small. one PR should usually cover one resource capability or one shared concern. if a PR crosses resource boundaries, split it.

target size:

  • ideal: one resource/data-source vertical slice or one shared helper
  • avoid: multiple new resources in one PR
  • avoid: schema + CRUD + import + acceptance + docs for several resources together
  • if a PR is hard to review in one sitting, split it

phase 0: v1 planning and issue disposition

PR 0.1: v1 scope and architecture

  • update architecture docs for v1 target surface
  • define durable-only boundary
  • list v1 core resources and non-goals
  • no implementation

PR 0.2: concerns and github issue disposition

  • update docs/concerns.md
  • classify open issues
  • explicitly decide expected handling for #24 and #25
  • no implementation

phase 1: codegen decision

PR 1.1: codegen decision doc

  • evaluate tfplugingen-framework
  • decide generated vs handwritten ownership
  • document whether v1 will adopt codegen

if codegen is accepted:

PR 1.2: generator tooling skeleton

  • add pinned generator command/script
  • generate one low-risk schema/model only
  • no broad migration

PR 1.3: codegen drift check

  • add CI drift check
  • document regeneration workflow

if codegen is rejected/deferred:

PR 1.2-alt: close codegen loop

  • document why handwritten remains v1 path
  • update docs/concerns.md
  • mark #25 resolved/deferred

phase 2: projects

PR 2.1: project API/client wrapper

  • add durable project client methods
  • tests only around client/wrapper behavior

PR 2.2: kernel_project resource create/read

  • schema/model
  • create/read
  • focused tests

PR 2.3: kernel_project update/delete/import

  • update semantics
  • delete semantics
  • import
  • tests

PR 2.4: project limits

  • either nested project limits or separate kernel_project_limits
  • only if API semantics are stable
  • tests/docs

PR 2.5: project acceptance/docs/examples

  • acceptance tests
  • generated docs
  • examples

phase 3: profiles

PR 3.1: profile client + schema/model

  • durable profile API wrapper
  • schema/model
  • tests

PR 3.2: kernel_profile create/read

  • create/read only
  • tests

PR 3.3: kernel_profile update/delete/import

  • update semantics
  • delete semantics
  • import
  • tests

PR 3.4: profile data source hardening

  • exact lookup behavior
  • pagination/ambiguity handling
  • tests

PR 3.5: profile acceptance/docs/examples

phase 4: proxies

PR 4.1: proxy client + schema/model

  • sensitive credential design
  • tests

PR 4.2: kernel_proxy create/read

  • create/read only
  • tests

PR 4.3: kernel_proxy update/delete/import

  • update vs replace
  • delete/import
  • tests

PR 4.4: proxy data source hardening

  • exact lookup
  • masked/sensitive fields
  • tests

PR 4.5: proxy acceptance/docs/examples

phase 5: extensions

PR 5.1: extension client + schema/model

  • decide upload vs reference semantics
  • file/hash design if uploads are supported
  • tests

PR 5.2: kernel_extension create/read

  • create/read only
  • tests

PR 5.3: kernel_extension update/delete/import

  • package/hash update behavior
  • delete/import
  • tests

PR 5.4: extension data source hardening

  • exact lookup
  • tests

PR 5.5: extension acceptance/docs/examples

phase 6: browser pool v1 hardening

PR 6.1: browser pool update/clear contract tests

  • profile/proxy/extensions/chrome_policy/start_url/viewport semantics
  • no feature expansion

PR 6.2: browser pool data source

  • add kernel_browser_pool data source if missing
  • exact lookup/import docs

PR 6.3: force_destroy decision

  • if rejected: docs/tests confirming default safe delete
  • if accepted: schema/model + default false only

PR 6.4: force_destroy implementation, only if accepted

  • delete plumbing
  • drift handling
  • acceptance coverage
  • docs warning

phase 7: apps/deployments

PR 7.1: deployment state design doc

  • decide source types
  • decide env var sensitivity
  • decide replace/update behavior
  • no implementation

PR 7.2: deployment client wrapper

  • create/list/get/delete methods
  • tests

PR 7.3: kernel_app data source

  • list/filter exact lookup
  • actions/version/deployment metadata
  • tests

PR 7.4: kernel_deployment create/read/delete

  • GitHub source path first
  • no local archive unless separately approved
  • tests

PR 7.5: deployment env vars and sensitive handling

  • sensitive map behavior
  • state risk docs
  • tests

PR 7.6: deployment import/replace semantics

  • import by deployment id
  • replace-on-change rules
  • tests

PR 7.7: deployment acceptance/docs/examples

optional:

PR 7.8: local archive deployment source

  • only if Terraform can model diffs safely
  • otherwise defer

phase 8: api keys

PR 8.1: api key Terraform state design

  • plaintext-once behavior
  • import limitations
  • rotation semantics
  • provider-self-delete warning
  • no implementation

PR 8.2: api key client wrapper

  • create/list/get/update/delete/rotate
  • tests

PR 8.3: kernel_api_key data source

  • masked metadata only
  • exact lookup
  • tests

PR 8.4: kernel_api_key create/read/update/delete

  • sensitive computed key on create only
  • metadata reads
  • tests

PR 8.5: api key rotation

  • explicit rotation trigger only
  • sensitive computed replacement key
  • tests

PR 8.6: api key acceptance/docs/examples

phase 9: v1 release readiness

PR 9.1: v1 acceptance matrix

  • document required acceptance tests per resource
  • add manual workflow updates if needed

PR 9.2: ci/release hardening

  • generated docs check
  • example validation
  • link check
  • release workflow/signing if not already present

PR 9.3: v1 docs and examples

  • complete generated docs
  • production examples
  • migration notes from v0

PR 9.4: v1 changelog/release checklist

  • final release checklist
  • known limitations
  • deferred v1.x items

PR splitting rule

before opening each PR, estimate review scope.

split the PR if it does more than one of:

  • introduces a new resource
  • introduces a new data source
  • changes shared provider architecture
  • adds release/ci infrastructure
  • adds acceptance infrastructure
  • resolves a cross-cutting sensitive-state design

tests and docs for the same resource may stay with that resource PR. shared helpers should be separate when more than one resource depends on them.

@IlyaasK
IlyaasK requested a review from Sayan- July 29, 2026 18:24

@Sayan- Sayan- left a comment

Copy link
Copy Markdown

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Strong PR. The gates are the right ones (strict semver, ancestor-of-main, public-visibility), actions are SHA-pinned, persist-credentials: false is set, and the tag reaches the shell through $GITHUB_REF_NAME rather than ${{ }} interpolation, so there's no injection path. I also like that the GORELEASER_CURRENT_TAG fix added an independent dist/metadata.json version cross-check instead of just trusting the env var — belt and braces is correct for a release path. And your read on actions/upload-artifact was right: it authenticates through ACTIONS_RUNTIME_TOKEN, not GITHUB_TOKEN, so contents: read is the correct least-privilege setting.

One thing worth planning around: this workflow has never executed, and it can't until the repository is public, because the visibility gate exits 1. There's no workflow_dispatch, so it's tag-only. That leaves three paths unexercised — test -s LICENSE, the visibility check, and git merge-base --is-ancestor "$GITHUB_SHA" origin/main. The last one depends on origin/main existing as a remote-tracking ref after a tag-triggered checkout. fetch-depth: 0 should provide that, but as written the first time it is ever evaluated would be the real first release tag.

Cheap insurance: once the repo is public and before the first real tag, push a throwaway v0.0.1 and confirm the workflow goes green. It's safe to do — --skip=publish,sign means no GitHub Release, no signature, and nothing reaches the registry. Worth writing into docs/release.md as an explicit step so it isn't left to memory on release day.

@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-artifacts branch from 59a6014 to ee70610 Compare July 29, 2026 20:31
@IlyaasK
IlyaasK force-pushed the hypeship/v1-release-prepare branch from 17d0c8a to 6a40866 Compare July 29, 2026 20:40
@IlyaasK
IlyaasK merged commit 2214841 into hypeship/v1-release-artifacts Jul 30, 2026
2 checks passed
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants