You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
Repository navigation
Commit 891040c
Browse filesBrowse the repository at this point in the historyBrowse files
🔐 Reach a protected remote as whoever is running the host
A workflow could clone a public repository and push to an unauthenticated
one, and nothing else. The Deno host built Git's environment from nothing so
a run would not depend on whose machine created it, and that same decision
left the invoking user's SSH agent, credential helpers and keychain out of
reach — so a private clone or a protected push needed a credential setup XMD
does not have and this issue refuses to introduce.
Authentication is now borrowed rather than configured. A command that
transports to a remote acquires it lazily, for that command's own exact
retained locator, and disposes it with the command: the ambient SSH agent for
SSH, a host-owned credential broker over `git credential fill` for HTTP, and
`GH_TOKEN`, then `GITHUB_TOKEN`, then `gh auth token` for the GitHub API,
shared now by every shipped GitHub adapter. A command that stays inside the
materialization reaches no mechanism at all, which is what makes a completed
replay reach none either.
Everything the environment was built from nothing for still holds. General
configuration is not admitted along with a credential, the destination stays
the exact retained locator, and `credential.helper` and `core.sshCommand`
join the family of settings fixed on the command line — so a helper planted
in a checkout's own `.git/config`, which is retained document data, cannot
run or replace the host-selected path. A missing or rejected credential is an
ordinary live refusal that proves no absence and adopts no completion.
Evidence is `git http-backend` behind a loopback listener that demands a
credential the suite invented: a clone, a push and an interrupted push that
reacquires and adopts, each proved by what the remote received. Nothing reads
a developer's real credential or contacts a network host.
Refs #522
Copy file name to clipboardExpand all lines: architecture.md
+24-5Lines changed: 24 additions & 5 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1119,10 +1119,29 @@ transaction is what makes an interrupted attempt reach the host once.
1119
1119
A provider that needs a program must also not inherit configuration the run
1120
1120
merely stores. A checkout's `.git/config` is retained document data, and several
1121
1121
ordinary settings in one name a destination or a program — a push URL, a URL
1122
-
rewrite, a hook, a credential helper, a signing program. The Deno push provider
1123
-
therefore runs its transport in a disposable repository of its own that reads
1124
-
the selected checkout's object database through a read-only alternate, and aims
1125
-
it at the exact private retained locator rather than at a configured remote.
1122
+
rewrite, a hook, a credential helper, an SSH command, a signing program. The
1123
+
Deno push provider therefore runs its transport in a disposable repository of
1124
+
its own that reads the selected checkout's object database through a read-only
1125
+
alternate, and aims it at the exact private retained locator rather than at a
1126
+
configured remote. The two settings that would otherwise choose how a remote
1127
+
operation authenticates — `credential.helper` and `core.sshCommand` — are fixed
1128
+
on the command line, where they outrank every configuration file, for every
1129
+
invocation that transports to a remote.
1130
+
1131
+
Authentication itself is the one live host input such an invocation borrows, and
1132
+
it is not the same question as inherited configuration. Retained state says
1133
+
which repository an effect belongs to; it must never say who the run is, because
1134
+
an identity belongs to the machine a run is standing on and a run resumed
1135
+
elsewhere authenticates as whoever is there then. So a remote-touching
1136
+
invocation acquires authentication lazily, for its own exact retained locator,
1137
+
after the authority checks that operation requires — the ambient SSH agent for
1138
+
SSH, a host-owned credential broker for HTTP, and `GH_TOKEN` then `GITHUB_TOKEN`
1139
+
then the machine's Git-host login for a Git-host API. It is attached to one
1140
+
command and disposed with it. A credential acquired for one locator never
1141
+
authorizes another, nothing about it is retained, and a completed replay reaches
1142
+
no authentication mechanism at all because it performs no remote operation to
1143
+
attach one to. A missing or rejected credential is ordinary live refusal: it
1144
+
proves no absence and adopts no completion.
1126
1145
1127
1146
Only an answer the terminal accepted decides the effect. A conflict, a permanent
1128
1147
ambiguity and a temporary unavailability so accepted publish the effect's failed
@@ -2560,7 +2579,7 @@ Status is measured against main.
2560
2579
|`<Repository>` / `<Worktree>` / `<Dir>` composition | names a Git repository and its linked checkouts inside the run-owned Workspace, installs each as contextual working directory, and retains creation identity beside the retained Git bytes | built on the #293 stack, Deno provider only |
2561
2580
| transactional Git effects (`Git.Switch` / `Git.Add` / `Git.Commit`) | publish local Git mutations with their journal result; the enclosing Repository and the contextual working directory select which retained checkout one runs in, and neither observation carries authority — the observed record is compared with the retained row and the directory with the checkouts that row holds, so a failure of authority, of retained state or of an unrecognized native condition fails the run instead of publishing a result | built on the #294 stack, Deno provider only |
2562
2581
|`Git.Push`| publishes the selected checkout's exact current named branch and commit to the same branch on the retained Repository's canonical `origin`, reconciled through the shared Git-host state machine rather than through a Workspace transaction: no props and no component result, no force, no upstream mutation and no implicit staging or committing; the durable request and record carry the Repository's filtered identity without its checkout path, and the transport runs in a provider-owned isolated control repository reading the checkout's objects through an object-source attachment whose alternates chain and object tree are proven contained before the first remote observation, aimed at the exact private retained locator | built on the #370 stack, Deno provider only |
2563
-
| `<PullRequest>` | upserts one pull request of the selected checkout's current named branch, reconciled through the shared Git-host state machine: a required `title`, an optional positive-integer `number`, an optional `base` defaulting to the Repository's retained initial branch, an optional `draft`, and the rendered content as the body; it renders nothing and returns stable evidence through `as` — the filtered Repository identity, the provider's own stable pull-request identity, number, URL, open state, and the head and base SHAs of the snapshot it finished at. Without a number it creates one pull request for the head/base pair or adopts the compatible one an interrupted attempt left; with a number it brings that exact pull request's title, body, draft state and base to what the request says, records a no-op when they already match, and refuses a number belonging to another repository, opened from another head, or no longer open. It never pushes, never rewrites a head, and never reopens, merges or comments. The run must already hold its own successful `Git.Push` result for that exact Repository identity, head branch, destination ref and commit — proven by a scan that requires the record's natural key, inputs and result to describe one publication — and a missing, conflicting or unreadable one fails locally before the Git host is observed; the first adapter works over `github.com` on REST plus the two GraphQL draft transitions, selected from the private retained locator, credentialed from `GH_TOKEN` then `GITHUB_TOKEN`, issuing each required mutation at most once per attempt and deciding the outcome by one observation, with the locator, endpoint, credential and payload confined to the per-invocation provider closure | built on the #295 stack, Deno provider only |
2582
+
| `<PullRequest>` | upserts one pull request of the selected checkout's current named branch, reconciled through the shared Git-host state machine: a required `title`, an optional positive-integer `number`, an optional `base` defaulting to the Repository's retained initial branch, an optional `draft`, and the rendered content as the body; it renders nothing and returns stable evidence through `as` — the filtered Repository identity, the provider's own stable pull-request identity, number, URL, open state, and the head and base SHAs of the snapshot it finished at. Without a number it creates one pull request for the head/base pair or adopts the compatible one an interrupted attempt left; with a number it brings that exact pull request's title, body, draft state and base to what the request says, records a no-op when they already match, and refuses a number belonging to another repository, opened from another head, or no longer open. It never pushes, never rewrites a head, and never reopens, merges or comments. The run must already hold its own successful `Git.Push` result for that exact Repository identity, head branch, destination ref and commit — proven by a scan that requires the record's natural key, inputs and result to describe one publication — and a missing, conflicting or unreadable one fails locally before the Git host is observed; the first adapter works over `github.com` on REST plus the two GraphQL draft transitions, selected from the private retained locator, credentialed from `GH_TOKEN`, then `GITHUB_TOKEN`, then the machine's own `gh` login, issuing each required mutation at most once per attempt and deciding the outcome by one observation, with the locator, endpoint, credential and payload confined to the per-invocation provider closure | built on the #295 stack, Deno provider only |
2564
2583
| `<Issue>` | asks one of two questions, decided by its own shape, through a boundary of its own rather than the Git host's. Self-closing with `url` reads that issue and binds `{ url, title, description, tags, assignee }`; paired with `title` upserts and binds exactly `{ url }`, its rendered content being the description. There is no `description` prop. Props are exactly `url`, `title`, optional `tags`, optional `assignee` and — on a read only — optional `provider`; no repository/token/label/milestone/project/comment/close or approval prop. Both forms render nothing. The form is decided before the tracker is read, before any provider is asked and before an `issue_effect` record exists, and that is where a mixed `url`+`title`, a read carrying content or `tags`/`assignee`, an upsert with no content, an upsert naming a `provider`, and an element that is neither are all refused. A read needs no tracker — its URL is the identity; an upsert requires the nearest lexical `<IssueTracker>` and takes its discriminator only from there. The tracker carries a credential-free `url` and an optional `provider`; the URL is canonicalized — a credential, a query and a fragment are refused rather than stripped — and a nested tracker replaces the whole value for its descendants, never merging members, with the enclosing one restored on leaving. It is composition data, not authority: the provider holds an adapter-private ceiling beside its credentials, admitted before it connects, so a target outside it sends nothing. One stable contextual operation, `executablemd.workflow.issue`, with `read(url, options)` and `upsert(issue, options)`; a provider is ordinary middleware around it, matching its own URLs without a discriminator and only its own name with one, independently per member, with no host-side resolution. Once middleware matches it owns the answer — it never delegates afterwards, and nothing catches its refusal to try somebody else — and a request everyone delegated reaches `NoIssueProvider` unchanged. `issue_effect` records an operation discriminator with the normalized request and result; both forms replay without reaching `IssueApi` and therefore without network access; only an upsert derives an idempotency key, from the operation, the canonical target and the run's own effect identity. Retention excludes credentials, endpoints, payloads, provider identities, origin markers and host paths. Observing, adopting, creating once and recovering an interrupted creation are the provider's, because they are knowledge about what a service can prove; title is never identity, and tags are a code-point-sorted set. The Deno workflow host installs configured GitHub middleware and installs none otherwise, so absence of configuration is fail-closed | built on the #296 stack; GitHub middleware, Deno host |
2565
2584
| workflow lifecycle inspection and control | reads status/list/history without advancing a run, recovering a private copy when a crashed source needs rollback; enforces the executor lock, refuses live cancellation, cancels non-live runs under that lock and deletes retained state | direct read-only inspection and control built on the #367 stack; coordinated recovered inspection built on the #513 stack, Deno provider only |
2566
2585
| historical authored source | retains an authored durable operation's normalized `SourcePosition` beside its identity, and history parses it or refuses the entry | built on the #367 stack |
0 commit comments