unfazed 0.6.1 → 0.8.1

package/dist/operations.d.ts

@@ -18,15 +18,35 @@ export declare const ListWorkspacesDocument: import("./index.js").TypedDocumentS
 /**
  * Deleting a workspace, with the deployment cascade made explicit.
  *
- * `withDeployments` is not decoration: without it the server REFUSES while the
- * workspace has any deployment history at all — including FAILED records —
- * with `workspace %q still has deployments; delete them first`. A workspace
- * that was ever deployed is therefore undeletable through the bare mutation,
- * so the SDK always sends the flag and lets the caller choose the value.
+ * Without `withDeployments` the server REFUSES while the workspace has any
+ * deployment record at all — FAILED ones included — with `workspace %q still
+ * has deployments; delete them first`. With it, the delete takes down every
+ * app the workspace serves, so `confirmAliases` must name exactly those apps
+ * (`Workspace.liveApps`); a missing or extra alias refuses the delete, deletes
+ * nothing, and the error lists the live apps. The SDK always sends the flag
+ * and never fills in the aliases: the caller names what goes.
  */
 export declare const DeleteWorkspaceDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkDeleteWorkspaceMutation, {
     workspaceID: string | number;
     withDeployments?: boolean | null | undefined | undefined;
+    confirmAliases?: string | string[] | null | undefined;
+}>;
+/**
+ * The apps a workspace serves right now: what `deleteWorkspace` with
+ * `withDeployments` takes offline, and exactly the list its `confirmAliases`
+ * must name. `workspace` is null when the id is absent or not the caller's.
+ */
+export declare const WorkspaceLiveAppsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWorkspaceLiveAppsQuery, {
+    id: string | number;
+}>;
+/**
+ * Deleting ONE app of a workspace: every deployment of the alias there, its
+ * App State, app-scoped env and secrets, and integration bindings. The
+ * workspace, its files and its other apps keep serving.
+ */
+export declare const DeleteAppDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkDeleteAppMutation, {
+    workspaceID: string | number;
+    alias: string;
 }>;
 export declare const WriteTextFileDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWriteTextFileMutation, {
     workspaceID: string | number;
@@ -38,6 +58,82 @@ export declare const WriteBase64FileDocument: import("./index.js").TypedDocument
     path: string;
     contentBase64: string;
 }>;
+/** The commit a file write made on an app with platform git (MCP's `commit`). */
+export declare const FileCommitFieldsFragment: import("./index.js").TypedDocumentString<import("./index.js").FileCommitFieldsFragment, unknown>;
+/**
+ * The batch write (MCP `write_workspace_files`): every file in ONE request
+ * and, on an app with platform git, ONE commit for the whole call.
+ */
+export declare const WriteFilesDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWriteFilesMutation, {
+    workspaceID: string | number;
+    files: Array<import("./index.js").WorkspaceFileWriteInput> | import("./index.js").WorkspaceFileWriteInput;
+    commitMessage?: string | null | undefined | undefined;
+}>;
+/** One page of an app's platform git history, newest first (MCP `list_commits`). */
+export declare const AppCommitsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkAppCommitsQuery, {
+    workspaceID: string | number;
+    limit?: number | null | undefined | undefined;
+    before?: string | null | undefined | undefined;
+}>;
+/** Only what `waitForCommit` reads: whether writes still wait, and the head. */
+export declare const AppCommitsWaitingDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkAppCommitsWaitingQuery, {
+    workspaceID: string | number;
+}>;
+/**
+ * The app's git link as the last import left it: what `restoreVersion` waits
+ * on, since the deploy a restore queues is an import of the branch head.
+ */
+export declare const WorkspaceGitSourceDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWorkspaceGitSourceQuery, {
+    id: string | number;
+}>;
+/** One commit with its diff (MCP `get_commit`). */
+export declare const AppCommitDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkAppCommitQuery, {
+    workspaceID: string | number;
+    sha: string;
+}>;
+/** Give the app back an earlier commit's files (MCP `restore_version`). */
+export declare const RestoreVersionDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkRestoreVersionMutation, {
+    workspaceID: string | number;
+    sha: string;
+    expectedHead?: string | null | undefined | undefined;
+    message?: string | null | undefined | undefined;
+}>;
+/** A service app's error group, as MCP `list_errors` shows it. */
+export declare const AppErrorGroupFieldsFragment: import("./index.js").TypedDocumentString<import("./index.js").AppErrorGroupFieldsFragment, unknown>;
+export declare const AppErrorsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkAppErrorsQuery, {
+    workspaceID: string | number;
+    alias: string;
+    status?: string | null | undefined | undefined;
+    limit?: number | null | undefined | undefined;
+    cursor?: string | null | undefined | undefined;
+}>;
+export declare const AppErrorGroupDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkAppErrorGroupQuery, {
+    workspaceID: string | number;
+    alias: string;
+    groupID: string | number;
+}>;
+export declare const ResolveErrorGroupDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkResolveErrorGroupMutation, {
+    input: import("./index.js").AppErrorGroupInput;
+}>;
+export declare const MuteErrorGroupDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkMuteErrorGroupMutation, {
+    input: import("./index.js").AppErrorGroupInput;
+}>;
+export declare const ReopenErrorGroupDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkReopenErrorGroupMutation, {
+    input: import("./index.js").AppErrorGroupInput;
+}>;
+/** The event types pollEvents/waitForEvents read (MCP `list_event_types`). */
+export declare const EventTypesDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkEventTypesQuery, {
+    [x: string]: never;
+}>;
+/** MCP `poll_events`: the same feed, cursors and filters. */
+export declare const PollEventsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkPollEventsQuery, {
+    input?: import("./index.js").PlatformEventsInput | null | undefined;
+}>;
+/** MCP `wait_for_events`: pollEvents that blocks server-side (at most 50 s). */
+export declare const WaitForEventsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWaitForEventsQuery, {
+    input?: import("./index.js").PlatformEventsInput | null | undefined;
+    timeoutSeconds?: number | null | undefined | undefined;
+}>;
 export declare const ListFilesDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkListFilesQuery, {
     input: import("./index.js").ListWorkspaceFilesInput;
 }>;
@@ -88,10 +184,53 @@ export declare const ServiceLogsDocument: import("./index.js").TypedDocumentStri
     deploymentID: string | number;
     tailBytes?: number | null | undefined | undefined;
 }>;
+/** A deploy's measured timeline in milliseconds, as the platform parsed it. */
+export declare const DeploymentTimingsFieldsFragment: import("./index.js").TypedDocumentString<import("./index.js").DeploymentTimingsFieldsFragment, unknown>;
+/**
+ * Deployment events with their metadata: the timing events
+ * (`deployment.phases`, `deployment.build_finished`) carry their phases there
+ * as `*_ms` strings and, parsed by the platform, as `timings`, which
+ * `parseDeploymentTimings` prefers.
+ */
 export declare const DeploymentEventsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkDeploymentEventsQuery, {
     deploymentID: string | number;
     limit?: number | null | undefined | undefined;
 }>;
+/**
+ * A deployment's timeline as the platform reads it from ALL its events (the
+ * latest of each timing event), not just a page of them.
+ */
+export declare const DeploymentTimingsDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkDeploymentTimingsQuery, {
+    id: string | number;
+}>;
+/**
+ * The server-side wait (MCP `wait_for_deployment`): the control plane blocks
+ * until the deployment leaves BUILDING — woken by the deploy pipeline itself,
+ * not a timer — or its budget (at most 50 s) runs out. One round trip after
+ * READY instead of a poll interval, and the full deployment in the answer.
+ *
+ * By id it asks only for what every platform with the wait answers, so a
+ * deploy's wait works on one from before the wait by commit too.
+ */
+export declare const WaitForDeploymentDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWaitForDeploymentQuery, {
+    id: string | number;
+    timeoutSeconds?: number | null | undefined | undefined;
+}>;
+/**
+ * The same wait for the deploy a git import makes of a commit, which has no
+ * id yet when a restore, push or sync answers: `deployment` is null until the
+ * import made it (`status` IMPORTING), and stays null with `status` FAILED
+ * and `importError` once the import failed on the commit. `after` counts only
+ * deployments begun after that point of the platform's deployment order
+ * (RestoreAppVersionPayload.waitAfter).
+ */
+export declare const WaitForCommitDeploymentDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkWaitForCommitDeploymentQuery, {
+    workspaceID: string | number;
+    gitCommit: string;
+    alias?: string | null | undefined | undefined;
+    after?: number | null | undefined | undefined;
+    timeoutSeconds?: number | null | undefined | undefined;
+}>;
 export declare const RestartServiceDocument: import("./index.js").TypedDocumentString<import("./index.js").SdkRestartServiceMutation, {
     deploymentID: string | number;
 }>;

package/dist/operations.js

@@ -100,19 +100,66 @@ export const ListWorkspacesDocument = graphql(`
 /**
  * Deleting a workspace, with the deployment cascade made explicit.
  *
- * `withDeployments` is not decoration: without it the server REFUSES while the
- * workspace has any deployment history at all — including FAILED records —
- * with `workspace %q still has deployments; delete them first`. A workspace
- * that was ever deployed is therefore undeletable through the bare mutation,
- * so the SDK always sends the flag and lets the caller choose the value.
+ * Without `withDeployments` the server REFUSES while the workspace has any
+ * deployment record at all — FAILED ones included — with `workspace %q still
+ * has deployments; delete them first`. With it, the delete takes down every
+ * app the workspace serves, so `confirmAliases` must name exactly those apps
+ * (`Workspace.liveApps`); a missing or extra alias refuses the delete, deletes
+ * nothing, and the error lists the live apps. The SDK always sends the flag
+ * and never fills in the aliases: the caller names what goes.
  */
 export const DeleteWorkspaceDocument = graphql(`
-  mutation SdkDeleteWorkspace($workspaceID: ID!, $withDeployments: Boolean) {
-    deleteWorkspace(input: { workspaceID: $workspaceID, withDeployments: $withDeployments }) {
+  mutation SdkDeleteWorkspace(
+    $workspaceID: ID!
+    $withDeployments: Boolean
+    $confirmAliases: [String!]
+  ) {
+    deleteWorkspace(
+      input: {
+        workspaceID: $workspaceID
+        withDeployments: $withDeployments
+        confirmAliases: $confirmAliases
+      }
+    ) {
       ok
     }
   }
 `);
+/**
+ * The apps a workspace serves right now: what `deleteWorkspace` with
+ * `withDeployments` takes offline, and exactly the list its `confirmAliases`
+ * must name. `workspace` is null when the id is absent or not the caller's.
+ */
+export const WorkspaceLiveAppsDocument = graphql(`
+  query SdkWorkspaceLiveApps($id: ID!) {
+    workspace(id: $id) {
+      id
+      liveApps {
+        alias
+        deploymentID
+        domains
+      }
+    }
+  }
+`);
+/**
+ * Deleting ONE app of a workspace: every deployment of the alias there, its
+ * App State, app-scoped env and secrets, and integration bindings. The
+ * workspace, its files and its other apps keep serving.
+ */
+export const DeleteAppDocument = graphql(`
+  mutation SdkDeleteApp($workspaceID: ID!, $alias: String!) {
+    deleteApp(input: { workspaceID: $workspaceID, alias: $alias }) {
+      ok
+      alias
+      deployments
+      domains
+      envEntries
+      skippedOnSync
+      otherApps
+    }
+  }
+`);
 export const WriteTextFileDocument = graphql(`
   mutation SdkWriteTextFile($workspaceID: ID!, $path: String!, $text: String!) {
     writeWorkspaceTextFile(input: { workspaceID: $workspaceID, path: $path, text: $text }) {
@@ -141,6 +188,309 @@ export const WriteBase64FileDocument = graphql(`
     }
   }
 `);
+/** The commit a file write made on an app with platform git (MCP's `commit`). */
+export const FileCommitFieldsFragment = graphql(`
+  fragment FileCommitFields on FileCommit {
+    sha
+    branch
+    message
+    committed
+    waiting
+    waitingCount
+    deploys
+    conflicts
+    writeSHA
+    paused
+  }
+`);
+/**
+ * The batch write (MCP `write_workspace_files`): every file in ONE request
+ * and, on an app with platform git, ONE commit for the whole call.
+ */
+export const WriteFilesDocument = graphql(`
+  mutation SdkWriteFiles(
+    $workspaceID: ID!
+    $files: [WorkspaceFileWriteInput!]!
+    $commitMessage: String
+  ) {
+    writeWorkspaceFiles(
+      input: { workspaceID: $workspaceID, files: $files, commitMessage: $commitMessage }
+    ) {
+      workspaceID
+      written
+      failed
+      totalBytes
+      files {
+        path
+        ok
+        error
+        file {
+          path
+          sizeBytes
+          size
+          sha256
+          updatedAt
+        }
+      }
+      commit {
+        ...FileCommitFields
+      }
+    }
+  }
+`);
+/** One page of an app's platform git history, newest first (MCP `list_commits`). */
+export const AppCommitsDocument = graphql(`
+  query SdkAppCommits($workspaceID: ID!, $limit: Int, $before: String) {
+    appCommits(workspaceID: $workspaceID, limit: $limit, before: $before) {
+      branch
+      head
+      nextBefore
+      autoDeploy
+      waitingCommits
+      waitingSince
+      commits {
+        sha
+        message
+        authorName
+        authorEmail
+        authoredAt
+        filesChanged
+        deployedTo
+      }
+      deployed {
+        alias
+        sha
+        deploymentID
+      }
+    }
+  }
+`);
+/** Only what `waitForCommit` reads: whether writes still wait, and the head. */
+export const AppCommitsWaitingDocument = graphql(`
+  query SdkAppCommitsWaiting($workspaceID: ID!) {
+    appCommits(workspaceID: $workspaceID, limit: 1) {
+      branch
+      head
+      waitingCommits
+      waitingSince
+    }
+  }
+`);
+/**
+ * The app's git link as the last import left it: what `restoreVersion` waits
+ * on, since the deploy a restore queues is an import of the branch head.
+ */
+export const WorkspaceGitSourceDocument = graphql(`
+  query SdkWorkspaceGitSource($id: ID!) {
+    workspace(id: $id) {
+      id
+      gitSource {
+        branch
+        autoDeploy
+        deployAlias
+        lastImportedCommit
+        lastImportedAt
+        lastImportStatus
+        lastImportError
+      }
+    }
+  }
+`);
+/** One commit with its diff (MCP `get_commit`). */
+export const AppCommitDocument = graphql(`
+  query SdkAppCommit($workspaceID: ID!, $sha: String!) {
+    appCommit(workspaceID: $workspaceID, sha: $sha) {
+      commit {
+        sha
+        message
+        authorName
+        authorEmail
+        authoredAt
+        filesChanged
+        deployedTo
+      }
+      files {
+        path
+        status
+      }
+      patch
+      truncated
+      additions
+      deletions
+    }
+  }
+`);
+/** Give the app back an earlier commit's files (MCP `restore_version`). */
+export const RestoreVersionDocument = graphql(`
+  mutation SdkRestoreVersion(
+    $workspaceID: ID!
+    $sha: String!
+    $expectedHead: String
+    $message: String
+  ) {
+    restoreAppVersion(
+      input: { workspaceID: $workspaceID, sha: $sha, expectedHead: $expectedHead, message: $message }
+    ) {
+      sha
+      committed
+      deploys
+      message
+      workspaceID
+      branch
+      deployAlias
+      restoredFrom
+      parent
+      waitAfter
+    }
+  }
+`);
+/** A service app's error group, as MCP `list_errors` shows it. */
+export const AppErrorGroupFieldsFragment = graphql(`
+  fragment AppErrorGroupFields on AppErrorGroup {
+    id
+    title
+    type
+    culprit
+    level
+    status
+    count
+    storedEvents
+    firstSeen
+    lastSeen
+    firstDeploymentID
+    firstGitCommit
+    lastDeploymentID
+    lastGitCommit
+    resolvedInDeploymentID
+    resolvedAt
+    mutedAt
+    regressedAt
+  }
+`);
+export const AppErrorsDocument = graphql(`
+  query SdkAppErrors(
+    $workspaceID: ID!
+    $alias: String!
+    $status: String
+    $limit: Int
+    $cursor: String
+  ) {
+    appErrors(
+      workspaceID: $workspaceID
+      alias: $alias
+      status: $status
+      limit: $limit
+      cursor: $cursor
+    ) {
+      groups {
+        ...AppErrorGroupFields
+      }
+      nextCursor
+      note
+    }
+  }
+`);
+export const AppErrorGroupDocument = graphql(`
+  query SdkAppErrorGroup($workspaceID: ID!, $alias: String!, $groupID: ID!) {
+    appErrorGroup(workspaceID: $workspaceID, alias: $alias, groupID: $groupID) {
+      group {
+        ...AppErrorGroupFields
+      }
+      latestEvent
+      firstEvent {
+        eventID
+        at
+        deploymentID
+        level
+      }
+      recentEvents {
+        eventID
+        at
+        deploymentID
+        level
+      }
+      deployments {
+        deploymentID
+        gitCommit
+        current
+        count
+        firstSeen
+        lastSeen
+      }
+      fatal
+      vmID
+    }
+  }
+`);
+export const ResolveErrorGroupDocument = graphql(`
+  mutation SdkResolveErrorGroup($input: AppErrorGroupInput!) {
+    resolveAppErrorGroup(input: $input) {
+      ...AppErrorGroupFields
+    }
+  }
+`);
+export const MuteErrorGroupDocument = graphql(`
+  mutation SdkMuteErrorGroup($input: AppErrorGroupInput!) {
+    muteAppErrorGroup(input: $input) {
+      ...AppErrorGroupFields
+    }
+  }
+`);
+export const ReopenErrorGroupDocument = graphql(`
+  mutation SdkReopenErrorGroup($input: AppErrorGroupInput!) {
+    reopenAppErrorGroup(input: $input) {
+      ...AppErrorGroupFields
+    }
+  }
+`);
+/** The event types pollEvents/waitForEvents read (MCP `list_event_types`). */
+export const EventTypesDocument = graphql(`
+  query SdkEventTypes {
+    platformEventTypes {
+      name
+      description
+      delivery
+      inputSchema
+      payloadSchema
+    }
+  }
+`);
+/** MCP `poll_events`: the same feed, cursors and filters. */
+export const PollEventsDocument = graphql(`
+  query SdkPollEvents($input: PlatformEventsInput) {
+    pollEvents(input: $input) {
+      cursor
+      truncated
+      hasMore
+      nextPollMs
+      timedOut
+      events {
+        eventID
+        name
+        timestamp
+        data
+      }
+    }
+  }
+`);
+/** MCP `wait_for_events`: pollEvents that blocks server-side (at most 50 s). */
+export const WaitForEventsDocument = graphql(`
+  query SdkWaitForEvents($input: PlatformEventsInput, $timeoutSeconds: Int) {
+    waitForEvents(input: $input, timeoutSeconds: $timeoutSeconds) {
+      cursor
+      truncated
+      hasMore
+      nextPollMs
+      timedOut
+      events {
+        eventID
+        name
+        timestamp
+        data
+      }
+    }
+  }
+`);
 export const ListFilesDocument = graphql(`
   query SdkListFiles($input: ListWorkspaceFilesInput!) {
     workspaceFilesPage(input: $input) {
@@ -307,6 +657,24 @@ export const ServiceLogsDocument = graphql(`
     }
   }
 `);
+/** A deploy's measured timeline in milliseconds, as the platform parsed it. */
+export const DeploymentTimingsFieldsFragment = graphql(`
+  fragment DeploymentTimingsFields on DeploymentTimings {
+    totalMs
+    buildMs
+    promoteMs
+    phases
+    buildMode
+    artifactTransport
+    buildMemoryMiB
+  }
+`);
+/**
+ * Deployment events with their metadata: the timing events
+ * (`deployment.phases`, `deployment.build_finished`) carry their phases there
+ * as `*_ms` strings and, parsed by the platform, as `timings`, which
+ * `parseDeploymentTimings` prefers.
+ */
 export const DeploymentEventsDocument = graphql(`
   query SdkDeploymentEvents($deploymentID: ID!, $limit: Int) {
     deploymentEvents(deploymentID: $deploymentID, limit: $limit) {
@@ -317,10 +685,83 @@ export const DeploymentEventsDocument = graphql(`
       severity
       message
       vmID
+      metadata
+      timings {
+        ...DeploymentTimingsFields
+      }
       createdAt
     }
   }
 `);
+/**
+ * A deployment's timeline as the platform reads it from ALL its events (the
+ * latest of each timing event), not just a page of them.
+ */
+export const DeploymentTimingsDocument = graphql(`
+  query SdkDeploymentTimings($id: ID!) {
+    deployment(id: $id) {
+      id
+      timings {
+        ...DeploymentTimingsFields
+      }
+    }
+  }
+`);
+/**
+ * The server-side wait (MCP `wait_for_deployment`): the control plane blocks
+ * until the deployment leaves BUILDING — woken by the deploy pipeline itself,
+ * not a timer — or its budget (at most 50 s) runs out. One round trip after
+ * READY instead of a poll interval, and the full deployment in the answer.
+ *
+ * By id it asks only for what every platform with the wait answers, so a
+ * deploy's wait works on one from before the wait by commit too.
+ */
+export const WaitForDeploymentDocument = graphql(`
+  query SdkWaitForDeployment($id: ID!, $timeoutSeconds: Int) {
+    waitForDeployment(id: $id, timeoutSeconds: $timeoutSeconds) {
+      timedOut
+      waitedMs
+      placement
+      deployment {
+        ...DeploymentFields
+      }
+    }
+  }
+`);
+/**
+ * The same wait for the deploy a git import makes of a commit, which has no
+ * id yet when a restore, push or sync answers: `deployment` is null until the
+ * import made it (`status` IMPORTING), and stays null with `status` FAILED
+ * and `importError` once the import failed on the commit. `after` counts only
+ * deployments begun after that point of the platform's deployment order
+ * (RestoreAppVersionPayload.waitAfter).
+ */
+export const WaitForCommitDeploymentDocument = graphql(`
+  query SdkWaitForCommitDeployment(
+    $workspaceID: ID!
+    $gitCommit: String!
+    $alias: String
+    $after: Int
+    $timeoutSeconds: Int
+  ) {
+    waitForDeployment(
+      workspaceID: $workspaceID
+      gitCommit: $gitCommit
+      alias: $alias
+      after: $after
+      timeoutSeconds: $timeoutSeconds
+    ) {
+      status
+      importStatus
+      importError
+      timedOut
+      waitedMs
+      deployment {
+        ...DeploymentFields
+      }
+    }
+  }
+`);
 export const RestartServiceDocument = graphql(`
   mutation SdkRestartService($deploymentID: ID!) {
     restartService(input: { deploymentID: $deploymentID }) {