g1t/packages/contracts/src/clients.ts
Pick any line to see why it is the way it is: the commit, the pull request and issue it came from, and what the agent was thinking.
| GitHub Actions on g1t, part three: .g1t/workflows, the pages, the docs | 1 | import type { ActionsApi } from "./actions"; |
| Billing accounts, terms and enterprises; g1t is no longer free | 2 | import type { BillingAdminApi, BillingApi } from "./billing"; |
| Deployments: a preview for every pull request, production on g1t.page | 3 | import type { DeploymentsApi } from "./deployments"; |
| Projects: what a workspace builds and runs, first on every page | 4 | import type { ProjectsApi } from "./projects"; |
| Events service in Rust, with RFC 3339 times and accurate push events | 5 | import type { EventsApi } from "./events"; |
| Billing on Stripe's pages, month-end charges, warnings; sudo by workspace | 6 | import type { IdentityAdminApi, IdentityApi } from "./identity"; |
| Integrations: your own model provider, alerts that open issues, tickets agents read | 7 | import type { IntegrationsApi } from "./integrations"; |
| Webhooks: every event, to your own addresses, signed and retried | 8 | import type { WebhooksApi } from "./webhooks"; |
| Rust repos service with shipping; pull requests kept in the model | 9 | import type { ReposApi } from "./repos"; |
| Work service in Rust, with RFC 3339 timestamps | 10 | import type { WorkApi } from "./work"; |
| API and MCP server, Rust identity service, registration, site redesign | 11 | |
| 12 | /** A service binding, as far as these clients need it. */ | |
| 13 | export type ServiceBinding = { | |
| 14 | fetch(input: string, init?: RequestInit): Promise<Response>; | |
| 15 | }; | |
| 16 | ||
| 17 | /** | |
| 18 | * Calls a method on a service that speaks the JSON protocol used by the | |
| 19 | * Rust services: `POST /rpc/<method>` with the arguments as the body. | |
| 20 | */ | |
| 21 | async function rpc<T>( | |
| 22 | service: ServiceBinding, | |
| 23 | method: string, | |
| 24 | args: object, | |
| 25 | ): Promise<T> { | |
| 26 | // The hostname is ignored; a service binding always reaches its service. | |
| 27 | const response = await service.fetch(`https://service/rpc/${method}`, { | |
| 28 | method: "POST", | |
| 29 | headers: { "content-type": "application/json" }, | |
| 30 | body: JSON.stringify(args), | |
| 31 | }); | |
| 32 | if (!response.ok) { | |
| 33 | throw new Error(`${method} failed with status ${response.status}`); | |
| 34 | } | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 35 | return (await response.json()) as T; |
| API and MCP server, Rust identity service, registration, site redesign | 36 | } |
| 37 | ||
| 38 | export function identityClient(service: ServiceBinding): IdentityApi { | |
| 39 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 40 | return { | |
| 41 | register: (username, email, password) => | |
| 42 | call("register", { username, email, password }), | |
| 43 | signIn: (username, password) => call("sign_in", { username, password }), | |
| 44 | signOut: (sessionToken) => call("sign_out", { sessionToken }), | |
| Email verification, password reset, and Git for AI scale positioning | 45 | resendVerification: (user) => call("resend_verification", { user }), |
| 46 | verifyEmail: (token) => call("verify_email", { token }), | |
| 47 | requestPasswordReset: (email) => call("request_password_reset", { email }), | |
| 48 | resetPassword: (token, password) => | |
| 49 | call("reset_password", { token, password }), | |
| Device sign-in replaces registering and minting tokens over the API | 50 | deviceStart: (clientName) => call("device_start", { clientName }), |
| 51 | deviceLookup: (userCode) => call("device_lookup", { userCode }), | |
| 52 | deviceResolve: (userCode, user, approve) => | |
| 53 | call("device_resolve", { userCode, user, approve }), | |
| 54 | deviceClaim: (deviceCode) => call("device_claim", { deviceCode }), | |
| OAuth 2.1 sign-in for MCP clients and other applications | 55 | oauthAuthorize: (user, approval) => call("oauth_authorize", { user, ...approval }), |
| 56 | oauthExchange: (code, codeVerifier, clientId, redirectUri) => | |
| 57 | call("oauth_exchange", { code, codeVerifier, clientId, redirectUri }), | |
| 58 | oauthRefresh: (refreshToken, clientId) => | |
| 59 | call("oauth_refresh", { refreshToken, clientId }), | |
| 60 | listOAuthGrants: (user) => call("list_oauth_grants", { user }), | |
| 61 | revokeOAuthGrant: (user, id) => call("revoke_oauth_grant", { user, id }), | |
| Workspaces own repositories | 62 | createWorkspace: (user, slug, name) => call("create_workspace", { user, slug, name }), |
| 63 | getWorkspace: (slug) => call("get_workspace", { slug }), | |
| 64 | listMembers: (slug, viewer) => call("list_members", { slug, viewer }), | |
| 65 | addMember: (actor, slug, username) => call("add_member", { actor, slug, username }), | |
| 66 | removeMember: (actor, slug, username) => | |
| 67 | call("remove_member", { actor, slug, username }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 68 | updateWorkspace: (actor, slug, details) => |
| 69 | call("update_workspace", { actor, slug, ...details }), | |
| Workspace names and icons, and a component kit for every control | 70 | setWorkspaceAvatar: (actor, slug, image) => call("set_workspace_avatar", { actor, slug, image }), |
| 71 | setUserAvatar: (user, image) => call("set_user_avatar", { user, image }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 72 | listWorkspaceTokens: (slug, viewer) => call("list_workspace_tokens", { slug, viewer }), |
| 73 | createWorkspaceToken: (actor, slug, name) => | |
| 74 | call("create_workspace_token", { actor, slug, name }), | |
| 75 | removeWorkspaceToken: (actor, slug, id) => | |
| 76 | call("remove_workspace_token", { actor, slug, id }), | |
| API and MCP server, Rust identity service, registration, site redesign | 77 | userForSession: (sessionToken) => call("user_for_session", { sessionToken }), |
| 78 | userForGitCredentials: (username, secret) => | |
| 79 | call("user_for_git_credentials", { username, secret }), | |
| 80 | userForAccessToken: (token) => call("user_for_access_token", { token }), | |
| 81 | userForSshKey: (fingerprint) => call("user_for_ssh_key", { fingerprint }), | |
| 82 | userByUsername: (username) => call("user_by_username", { username }), | |
| What happened across an outcome, as a feed beside its graph | 83 | usernames: (ids) => call("usernames", { ids }), |
| API and MCP server, Rust identity service, registration, site redesign | 84 | listSshKeys: (user) => call("list_ssh_keys", { user }), |
| 85 | addSshKey: (user, title, publicKey) => | |
| 86 | call("add_ssh_key", { user, title, publicKey }), | |
| 87 | removeSshKey: (user, id) => call("remove_ssh_key", { user, id }), | |
| 88 | listAccessTokens: (user) => call("list_access_tokens", { user }), | |
| Account dropdown, llms.txt onboarding, hosted agent runner (not yet deployed) | 89 | createAccessToken: (user, name, ttlSeconds) => |
| 90 | call("create_access_token", { user, name, ttlSeconds }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 91 | createAgentToken: (onBehalfOf, scope, ttlSeconds) => |
| 92 | call("create_agent_token", { onBehalfOf, scope, ttlSeconds }), | |
| API and MCP server, Rust identity service, registration, site redesign | 93 | removeAccessToken: (user, id) => call("remove_access_token", { user, id }), |
| 94 | }; | |
| 95 | } | |
| Rust repos service with shipping; pull requests kept in the model | 96 | |
| Billing on Stripe's pages, month-end charges, warnings; sudo by workspace | 97 | /** Staff-only identity. Only sudo binds to it; see `IdentityAdminApi`. */ |
| 98 | export function identityAdminClient(service: ServiceBinding): IdentityAdminApi { | |
| 99 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 100 | return { | |
| 101 | workspaces: (query) => call("admin_workspaces", { query: query ?? null }), | |
| 102 | workspace: (slug) => call("admin_workspace", { slug }), | |
| 103 | }; | |
| 104 | } | |
| 105 | ||
| Rust repos service with shipping; pull requests kept in the model | 106 | export function reposClient(service: ServiceBinding): ReposApi { |
| 107 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 108 | return { | |
| 109 | get: (path, viewer) => call("get", { path, viewer }), | |
| 110 | getById: (id, viewer) => call("get_by_id", { id, viewer }), | |
| 111 | list: (viewer, options = {}) => call("list", { viewer, ...options }), | |
| 112 | create: (owner, input) => call("create", { owner, ...input }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 113 | update: (actor, path, changes) => call("update", { actor, path, ...changes }), |
| Rust repos service with shipping; pull requests kept in the model | 114 | tree: (path, viewer, ref, treePath) => |
| 115 | call("tree", { path, viewer, ref, treePath }), | |
| 116 | blob: (path, viewer, ref, filePath) => | |
| 117 | call("blob", { path, viewer, ref, filePath }), | |
| 118 | log: (path, viewer, ref, limit) => call("log", { path, viewer, ref, limit }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 119 | blame: (path, viewer, ref, filePath) => call("blame", { path, viewer, ref, filePath }), |
| Issues and pull requests replace intents and attempts | 120 | forkForPull: (sourceId, pullId, actor) => |
| 121 | call("fork_for_pull", { sourceId, pullId, actor }), | |
| Rust repos service with shipping; pull requests kept in the model | 122 | gitAccess: (path, viewer, service) => |
| 123 | call("git_access", { path, viewer, service }), | |
| Pull requests from branches | 124 | branches: (path, viewer) => call("branches", { path, viewer }), |
| 125 | land: (sourceId, actor, branch) => call("land", { sourceId, actor, branch }), | |
| 126 | compare: (repoId, viewer, base, head) => call("compare", { repoId, viewer, base, head }), | |
| Rust repos service with shipping; pull requests kept in the model | 127 | }; |
| 128 | } | |
| Work service in Rust, with RFC 3339 timestamps | 129 | |
| 130 | export function workClient(service: ServiceBinding): WorkApi { | |
| 131 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 132 | return { | |
| Issues and pull requests replace intents and attempts | 133 | openIssue: (actor, repo, input) => call("open_issue", { actor, repo, ...input }), |
| 134 | listIssues: (repo, viewer, filter = {}) => call("list_issues", { repo, viewer, ...filter }), | |
| 135 | getIssue: (repo, number, viewer) => call("get_issue", { repo, number, viewer }), | |
| 136 | updateIssue: (actor, repo, number, input) => | |
| 137 | call("update_issue", { actor, repo, number, ...input }), | |
| 138 | closeIssue: (actor, repo, number, reason) => | |
| 139 | call("close_issue", { actor, repo, number, reason }), | |
| 140 | reopenIssue: (actor, repo, number) => call("reopen_issue", { actor, repo, number }), | |
| 141 | listLabels: (repo, viewer) => call("list_labels", { repo, viewer }), | |
| 142 | counts: (repo, viewer) => call("counts", { repo, viewer }), | |
| Acceptance checks in sandboxes, line comments and review verdicts | 143 | addComment: (actor, repo, number, comment) => |
| 144 | call("add_comment", { actor, repo, number, ...comment }), | |
| 145 | startChecks: (pullId) => call("start_checks", { pullId }), | |
| 146 | reportChecks: (runId, token, report) => | |
| 147 | call("report_checks", { runId, token, ...report }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 148 | startReview: (pullId) => call("start_review", { pullId }), |
| 149 | failReview: (runId, token, error) => call("report_review", { runId, token, error }), | |
| 150 | advance: (pullId) => call("advance", { pullId }), | |
| 151 | stall: (pullId, reason) => call("stall", { pullId, reason }), | |
| 152 | managedPulls: (repoId) => call("managed_pulls", { repoId }), | |
| 153 | queue: (repo, viewer) => call("queue", { repo, viewer }), | |
| 154 | queueBuild: (repoId) => call("queue_build", { repoId }), | |
| 155 | failQueue: (entryId, token, error) => call("report_queue", { entryId, token, error }), | |
| 156 | removeFromQueue: (actor, repo, number) => call("remove_from_queue", { actor, repo, number }), | |
| Usage, like a hosting provider's: what agents cost, per day, task, repository and pull request | 157 | messageAgent: (actor, repo, number, body) => call("message_agent", { actor, repo, number, body }), |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 158 | catchUpJob: (pullId) => call("catch_up_job", { pullId }), |
| Agents asked while not at work are woken to answer | 159 | wakeForMessages: (pullId) => call("wake_for_messages", { pullId }), |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 160 | getSettings: (repo, viewer) => call("get_settings", { repo, viewer }), |
| 161 | updateSettings: (actor, repo, settings) => | |
| 162 | call("update_settings", { actor, repo, settings }), | |
| Issues and pull requests replace intents and attempts | 163 | openPull: (actor, repo, input) => call("open_pull", { actor, repo, ...input }), |
| 164 | listPulls: (repo, viewer, state) => call("list_pulls", { repo, viewer, state }), | |
| 165 | getPull: (repo, number, viewer) => call("get_pull", { repo, number, viewer }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 166 | updatePull: (actor, repo, number, changes) => |
| 167 | call("update_pull", { actor, repo, number, ...changes }), | |
| Issues and pull requests replace intents and attempts | 168 | readyPull: (actor, repo, number, summary) => |
| 169 | call("ready_pull", { actor, repo, number, summary }), | |
| 170 | closePull: (actor, repo, number) => call("close_pull", { actor, repo, number }), | |
| Acceptance checks in sandboxes, line comments and review verdicts | 171 | mergePull: (actor, repo, number, options = {}) => |
| 172 | call("merge_pull", { actor, repo, number, ...options }), | |
| Issues and pull requests replace intents and attempts | 173 | listActivePulls: (viewer) => call("list_active_pulls", { viewer }), |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 174 | startPlan: (actor, repo, brief) => call("start_plan", { actor, repo, brief }), |
| 175 | failPlan: (planId, token, error) => call("report_plan", { planId, token, error }), | |
| 176 | getPlan: (repo, viewer, id) => call("get_plan", { repo, viewer, id }), | |
| 177 | listPlans: (repo, viewer) => call("list_plans", { repo, viewer }), | |
| 178 | applyPlan: (actor, repo, id, options = {}) => | |
| 179 | call("apply_plan", { actor, repo, id, ...options }), | |
| 180 | queueIssue: (actor, repo, number, queued) => | |
| 181 | call("queue_issue", { actor, repo, number, queued }), | |
| 182 | readyIssues: (repoId) => call("ready_issues", { repoId }), | |
| 183 | listAssignedIssues: (viewer) => call("list_assigned_issues", { viewer }), | |
| Issues and pull requests replace intents and attempts | 184 | appendSession: (actor, repo, number, entries) => |
| 185 | call("append_session", { actor, repo, number, entries }), | |
| 186 | readSession: (repo, number, viewer, afterSeq = 0) => | |
| 187 | call("read_session", { repo, number, viewer, afterSeq }), | |
| Work service in Rust, with RFC 3339 timestamps | 188 | }; |
| 189 | } | |
| Events service in Rust, with RFC 3339 times and accurate push events | 190 | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 191 | export function billingClient(service: ServiceBinding): BillingApi { |
| 192 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 193 | return { | |
| 194 | status: () => call("status", {}), | |
| 195 | account: (workspace, viewer) => call("account", { workspace, viewer }), | |
| 196 | ledger: (workspace, viewer) => call("ledger", { workspace, viewer }), | |
| Usage, like a hosting provider's: what agents cost, per day, task, repository and pull request | 197 | usage: (workspace, viewer, since) => call("usage", { workspace, viewer, since }), |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 198 | checkout: (actor, workspace, amountCents, returnUrl) => |
| 199 | call("checkout", { actor, workspace, amountCents, returnUrl }), | |
| 200 | confirm: (workspace, viewer, session) => call("confirm", { workspace, viewer, session }), | |
| 201 | canStart: (workspace) => call("can_start", { workspace }), | |
| A free allowance on g1t's models, so anyone can try its agents | 202 | trial: (workspace, exempt) => call("trial", { workspace, exempt }), |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 203 | startRun: (run) => call("start_run", run), |
| Paid features: a workspace turns on Deployments with a monthly plan | 204 | features: (workspace, viewer) => call("features", { workspace, viewer }), |
| 205 | subscribe: (actor, workspace, feature, returnUrl) => | |
| 206 | call("subscribe", { actor, workspace, feature, returnUrl }), | |
| 207 | confirmSubscription: (workspace, viewer, session) => | |
| 208 | call("confirm_subscription", { workspace, viewer, session }), | |
| 209 | cancelSubscription: (actor, workspace, feature, resume = false) => | |
| 210 | call("cancel_subscription", { actor, workspace, feature, resume }), | |
| 211 | hasFeature: (workspace, feature) => call("has_feature", { workspace, feature }), | |
| 212 | chargeFeature: (charge) => call("charge_feature", charge), | |
| Billing on Stripe's pages, month-end charges, warnings; sudo by workspace | 213 | billingPortal: (actor, workspace, returnUrl) => call("billing_portal", { actor, workspace, return_url: returnUrl }), |
| Every sandbox is metered by the second | 214 | recordSandbox: (usage) => call("record_sandbox", usage), |
| Usage limits: unpaid usage can only go so far | 215 | limit: (workspace, viewer) => call("limit", { workspace, viewer }), |
| 216 | checkLimit: (workspace) => call("check_limit", { workspace }), | |
| Prices keep themselves current with what g1t pays | 217 | prices: () => call("prices", {}), |
| 218 | notePending: (workspace, source, costMicros) => call("note_pending", { workspace, source, costMicros }), | |
| Two limits, real invoices, trust that grows by itself, sales signals | 219 | setSpendLimit: (actor, workspace, spendLimitMicros, useFullLimit = false) => |
| 220 | call("set_spend_limit", { actor, workspace, spendLimitMicros, use_full_limit: useFullLimit }), | |
| 221 | invoices: (workspace, viewer) => call("invoices", { workspace, viewer }), | |
| Agents as a team: lifecycle, merge queue, billing and a new shell | 222 | }; |
| 223 | } | |
| 224 | ||
| Billing accounts, terms and enterprises; g1t is no longer free | 225 | export function billingAdminClient(service: ServiceBinding): BillingAdminApi { |
| 226 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 227 | return { | |
| 228 | accounts: (query) => call("admin_accounts", { query: query ?? null }), | |
| 229 | account: (id) => call("admin_account", { id }), | |
| 230 | setTerms: (id, terms, by) => call("admin_set_terms", { id, terms, by }), | |
| 231 | createEnterprise: (name, workspaces, by) => call("admin_create_enterprise", { name, workspaces, by }), | |
| 232 | attach: (workspace, account, by) => call("admin_attach", { workspace, account, by }), | |
| 233 | credit: (workspace, amountMicros, note, by) => call("admin_credit", { workspace, amount_micros: amountMicros, note, by }), | |
| Billing on Stripe's pages, month-end charges, warnings; sudo by workspace | 234 | billingLink: (workspace, by) => call("admin_billing_link", { workspace, by }), |
| Stripe webhooks, enterprise invoices, and sudo for both | 235 | stripe: (setup = false, by) => call("admin_stripe", { setup, by: by ?? null }), |
| 236 | enterpriseBilling: (id, email, by) => call("admin_enterprise_billing", { id, email, by }), | |
| 237 | invoiceEnterprise: (id, by) => call("admin_invoice_enterprise", { id, by }), | |
| 238 | accountsFor: (workspaces) => call("admin_accounts", { query: null, workspaces }), | |
| Two limits, real invoices, trust that grows by itself, sales signals | 239 | signals: () => call("admin_signals", {}), |
| 240 | overview: () => call("admin_overview", {}), | |
| 241 | sales: (workspace) => call("admin_sales", { workspace }), | |
| 242 | setSales: (workspace, record, by) => | |
| 243 | call("admin_set_sales", { | |
| 244 | workspace, | |
| 245 | stage: record.stage, | |
| 246 | owner: record.owner ?? null, | |
| 247 | next_step: record.nextStep ?? null, | |
| 248 | next_at: record.nextAt ?? null, | |
| 249 | by, | |
| 250 | }), | |
| 251 | addNote: (workspace, text, by) => call("admin_add_note", { workspace, text, by }), | |
| 252 | workspaceInvoices: (workspace) => call("admin_workspace_invoices", { workspace }), | |
| Billing lists every invoice and every staff change; signals carry follow-ups | 253 | allInvoices: (filter = {}) => call("admin_invoices", { status: filter.status ?? null, month: filter.month ?? null }), |
| 254 | audit: (filter = {}) => | |
| 255 | call("admin_audit", { by: filter.by ?? null, action: filter.action ?? null, before: filter.before ?? null }), | |
| Billing accounts, terms and enterprises; g1t is no longer free | 256 | }; |
| 257 | } | |
| 258 | ||
| Events service in Rust, with RFC 3339 times and accurate push events | 259 | export function eventsClient(service: ServiceBinding): EventsApi { |
| 260 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 261 | return { | |
| 262 | publish: (events) => call("publish", { events }), | |
| 263 | list: (query) => call("list", query), | |
| 264 | }; | |
| 265 | } | |
| Integrations: your own model provider, alerts that open issues, tickets agents read | 266 | |
| 267 | export function integrationsClient(service: ServiceBinding): IntegrationsApi { | |
| 268 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 269 | return { | |
| 270 | list: (workspace, viewer) => call("list", { workspace, viewer }), | |
| 271 | connect: (actor, workspace, input) => call("connect", { actor, workspace, ...input }), | |
| 272 | update: (actor, workspace, id, input) => call("update", { actor, workspace, id, ...input }), | |
| 273 | disconnect: (actor, workspace, id) => call("disconnect", { actor, workspace, id }), | |
| 274 | test: (actor, workspace, id) => call("test", { actor, workspace, id }), | |
| 275 | deliveries: (workspace, viewer, id) => call("deliveries", { workspace, viewer, id }), | |
| 276 | resolve: (workspace, viewer, reference) => call("resolve", { workspace, viewer, reference }), | |
| 277 | references: (workspace, text, limit) => call("references", { workspace, text, limit }), | |
| 278 | import: (actor, repo, reference, assign) => call("import", { actor, repo, reference, assign }), | |
| 279 | links: (repo, number) => call("links", { repo, number }), | |
| 280 | modelProvider: (workspace) => call("model_provider", { workspace }), | |
| 281 | openModelSession: (run) => call("open_model_session", run), | |
| 282 | modelUpstream: (token) => call("model_upstream", { token }), | |
| Models per workspace: several providers, routed by kind of work | 283 | routes: (workspace, viewer) => call("routes", { workspace, viewer }), |
| 284 | setRoutes: (actor, workspace, routes) => call("set_routes", { actor, workspace, routes }), | |
| Integrations: your own model provider, alerts that open issues, tickets agents read | 285 | }; |
| 286 | } | |
| Webhooks: every event, to your own addresses, signed and retried | 287 | |
| 288 | export function webhooksClient(service: ServiceBinding): WebhooksApi { | |
| 289 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 290 | return { | |
| 291 | list: (viewer, owner) => call("list", { viewer, ...owner }), | |
| 292 | create: (actor, owner, input) => call("create", { actor, ...owner, ...input }), | |
| 293 | update: (actor, owner, id, input) => call("update", { actor, ...owner, id, ...input }), | |
| 294 | delete: (actor, owner, id) => call("delete", { actor, ...owner, id }), | |
| 295 | ping: (actor, owner, id) => call("ping", { actor, ...owner, id }), | |
| 296 | deliveries: (viewer, owner, id) => call("deliveries", { viewer, ...owner, id }), | |
| 297 | redeliver: (actor, owner, deliveryId) => call("redeliver", { actor, ...owner, deliveryId }), | |
| 298 | }; | |
| 299 | } | |
| Automations: rules in .g1t/automations that act when something happens | 300 | |
| GitHub Actions on g1t, part three: .g1t/workflows, the pages, the docs | 301 | export function actionsClient(service: ServiceBinding): ActionsApi { |
| 302 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 303 | return { | |
| 304 | workflows: (repo, viewer) => call("workflows", { repo, viewer }), | |
| 305 | runs: (repo, viewer, filter = {}) => call("runs", { repo, viewer, ...filter }), | |
| 306 | run: (repo, viewer, id) => call("run", { repo, viewer, id }), | |
| 307 | logs: (repo, viewer, job, after = 0) => call("logs", { repo, viewer, job, after }), | |
| 308 | dispatch: (actor, repo, workflow, ref, inputs) => call("dispatch", { actor, repo, workflow, ref, inputs }), | |
| 309 | cancel: (actor, repo, id) => call("cancel", { actor, repo, id }), | |
| 310 | rerun: (actor, repo, id, failedOnly = false) => call("rerun", { actor, repo, id, failed_only: failedOnly }), | |
| 311 | setWorkflowEnabled: (actor, repo, workflow, enabled) => | |
| 312 | call("set_workflow_enabled", { actor, repo, workflow, enabled }), | |
| 313 | settings: (actor, owner, kind) => call("settings", { actor, ...owner, kind }), | |
| Secrets and variables: one list, rows per environment, for workflows and deployments | 314 | setSetting: (actor, owner, kind, name, value, options = {}) => |
| 315 | call("set_setting", { actor, ...owner, kind, name, value, ...options }), | |
| 316 | deleteSetting: (actor, owner, kind, name, id) => call("delete_setting", { actor, ...owner, kind, name, id }), | |
| GitHub Actions on g1t, part three: .g1t/workflows, the pages, the docs | 317 | }; |
| 318 | } | |
| 319 | ||
| Deployments: a preview for every pull request, production on g1t.page | 320 | |
| 321 | export function deploymentsClient(service: ServiceBinding): DeploymentsApi { | |
| 322 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 323 | return { | |
| Projects: what a workspace builds and runs, first on every page | 324 | settings: (project, viewer) => call("settings", { project, viewer }), |
| 325 | updateSettings: (actor, project, changes) => call("update_settings", { actor, project, changes }), | |
| 326 | list: (project, viewer) => call("list", { project, viewer }), | |
| 327 | get: (project, id, viewer) => call("get", { project, id, viewer }), | |
| 328 | redeploy: (actor, project, branch) => call("redeploy", { actor, project, branch }), | |
| 329 | takeDown: (actor, project, branch) => call("take_down", { actor, project, branch }), | |
| Project dependencies: addresses, preview stacks, Affects, and agents who know | 330 | stack: (actor, project, branch) => call("stack", { actor, project, branch }), |
| Projects: what a workspace builds and runs, first on every page | 331 | overview: (workspace, viewer) => call("overview", { workspace, viewer }), |
| Deployments: a preview for every pull request, production on g1t.page | 332 | usage: (workspace, viewer) => call("usage", { workspace, viewer }), |
| 333 | }; | |
| 334 | } | |
| Projects: what a workspace builds and runs, first on every page | 335 | |
| 336 | export function projectsClient(service: ServiceBinding): ProjectsApi { | |
| 337 | const call = <T>(method: string, args: object) => rpc<T>(service, method, args); | |
| 338 | return { | |
| 339 | list: (workspace, viewer) => call("list", { workspace, viewer }), | |
| 340 | get: (workspace, slug, viewer) => call("get", { workspace, slug, viewer }), | |
| 341 | byRepo: (repoId) => call("by_repo", { repoId }), | |
| 342 | create: (actor, workspace, input) => call("create", { actor, workspace, input }), | |
| 343 | update: (actor, workspace, slug, changes) => call("update", { actor, workspace, slug, changes }), | |
| Project dependencies: addresses, preview stacks, Affects, and agents who know | 344 | dependencies: (workspace, slug, viewer) => call("dependencies", { workspace, slug, viewer }), |
| 345 | addDependency: (actor, workspace, slug, on, as) => call("add_dependency", { actor, workspace, slug, on, as }), | |
| 346 | removeDependency: (actor, workspace, slug, on) => call("remove_dependency", { actor, workspace, slug, on }), | |
| 347 | graph: (projectId) => call("graph", { projectId }), | |
| Projects: what a workspace builds and runs, first on every page | 348 | }; |
| 349 | } |