@cofy-x/axern-sdk 0.6.2 → 0.8.0

package/dist/config/index.js

@@ -3,7 +3,6 @@ import { readFileSync } from "node:fs";
 export function loadAxernEnv(overrides = {}) {
     return {
         endpoint: overrides.endpoint ?? process.env.AXERN_ENDPOINT ?? "127.0.0.1:25000",
-        serviceUrl: overrides.serviceUrl ?? process.env.AXERN_SERVICE_URL,
         sshEndpoint: overrides.sshEndpoint ?? process.env.AXERN_SSH_ENDPOINT,
         sshIdentityFile: overrides.sshIdentityFile ?? process.env.AXERN_SSH_IDENTITY_FILE,
         tlsCaCert: overrides.tlsCaCert ?? process.env.AXERN_TLS_CA_CERT,
@@ -15,18 +14,17 @@ export function loadAxernEnv(overrides = {}) {
 }
 export function loadAxernContext(path, name = "") {
     const file = JSON.parse(readFileSync(path, "utf8"));
-    rejectUnknown(file, ["current_context", "contexts", "agent_profiles"], "config");
+    rejectUnknown(file, ["current_context", "contexts"], "config");
     const contextName = name || stringValue(file.current_context);
     if (!contextName)
         throw new Error("Axern context name is required");
     const contexts = objectValue(file.contexts, "contexts");
     const context = objectValue(contexts[contextName], `context ${JSON.stringify(contextName)}`);
-    rejectUnknown(context, ["endpoint", "service_url", "ssh_endpoint", "ssh_identity_file", "tls", "proxy_mode"], "context");
+    rejectUnknown(context, ["endpoint", "ssh_endpoint", "ssh_identity_file", "tls", "proxy_mode"], "context");
     const tls = objectValue(context.tls, "context.tls");
     rejectUnknown(tls, ["ca_cert", "cert", "key", "server_name"], "context.tls");
     const config = {
         endpoint: stringValue(context.endpoint),
-        serviceUrl: stringValue(context.service_url) || undefined,
         sshEndpoint: stringValue(context.ssh_endpoint) || undefined,
         sshIdentityFile: stringValue(context.ssh_identity_file) || undefined,
         tlsCaCert: stringValue(tls.ca_cert),

package/dist/generated/proto.js

@@ -16,7 +16,6 @@ const defaultProtoRootCandidates = [
 const protoFiles = [
     "axern/control/environment/v1/environment.proto",
     "axern/control/run/v1/run.proto",
-    "axern/control/service/v1/service.proto",
     "axern/control/tunnel/v1/tunnel.proto",
     "axern/node/sandbox/v1/node.proto",
     "axern/tunnel/v1/tunnel.proto",

package/dist/index.d.ts

@@ -4,18 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 export { AxernClient } from "./client/index.js";
-export type { AxernClientOptions, CreateEnvironmentOptions, CreateServiceOptions, } from "./client/index.js";
+export type { AxernClientOptions, CreateEnvironmentOptions, CreateRunOptions, DeclaredOutput, DeclaredOutputFormat, ListOptions, ListResult, SealedOutput, } from "./client/index.js";
 export { loadAxernContext, loadAxernEnv } from "./config/index.js";
 export type { AxernConfig } from "./config/index.js";
 export { AxernError, AxernRpcError, isNotFound, isCancelled, isUnavailable, errorRetryable, isPermissionDenied, isTimeout, rpcCode, SandboxExecError, SandboxStateError, SandboxTimeoutError, SandboxValidationError, } from "./errors/index.js";
-export { NodeSandboxClient } from "./node/client.js";
-export type { NodeSandboxClientOptions } from "./node/client.js";
+export { AllocationClient } from "./node/client.js";
+export type { AllocationClientOptions } from "./node/client.js";
 export { SandboxProcess } from "./node/process.js";
 export type { ResourceQuantity } from "./resources.js";
 export { Sandbox } from "./sandbox/index.js";
 export type { SandboxMetadata, SandboxOptions, SandboxState } from "./sandbox/index.js";
 export { NetworkPolicy, cidrRule, portRange } from "./network-policy.js";
 export type { CIDRRule, PortRange, StrictNetworkPolicyOptions } from "./network-policy.js";
-export type { ChmodOptions, CapabilityDependencyStatus, CapabilityProviderStatus, CapabilityProviderSummary, CapabilityStatus, Command, ComputerUseDependencyStatus, ComputerUseDisplay, ComputerUseKeyboardOptions, ComputerUseMouseOptions, ComputerUseRegion, ComputerUseScreenshot, ComputerUseScreenshotOptions, ComputerUseStatus, CopyOptions, DownloadArchiveOptions, DownloadDirOptions, ExecOptions, ExecResult, ImageExecOptions, ImageProcessMount, ImageProcessOptions, MkdirOptions, MoveOptions, NodeCallOptions, ProcessEvent, ProcessOptions, ProcessResult, RemoveOptions, SandboxFileInfo, SandboxFileKind, TouchOptions, TunnelConnectorOptions, TunnelMetadata, TunnelOptions, UploadArchiveOptions, UploadDirOptions, VolumeMount, WriteFileOptions, } from "./types.js";
-export { workspaceMount } from "./types.js";
+export type { ChmodOptions, CapabilityProviderDependencyStatus, CapabilityProviderStatus, CapabilityProviderSummary, CapabilityStatus, Command, ComputerUseDependencyStatus, ComputerUseDisplay, ComputerUseKeyboardOptions, ComputerUseMouseOptions, ComputerUseRegion, ComputerUseScreenshot, ComputerUseScreenshotOptions, ComputerUseStatus, CopyOptions, DownloadArchiveOptions, DownloadDirOptions, ExecOptions, ExecResult, MkdirOptions, MoveOptions, NodeCallOptions, ProcessEvent, ProcessOptions, ProcessResult, RemoveOptions, SandboxFileInfo, SandboxFileKind, TouchOptions, TunnelConnectorOptions, TunnelMetadata, TunnelOptions, UploadArchiveOptions, UploadDirOptions, WriteFileOptions, } from "./types.js";
 export { AXERN_VERSION, platformName } from "./version.js";

package/dist/index.js

@@ -6,9 +6,8 @@
 export { AxernClient } from "./client/index.js";
 export { loadAxernContext, loadAxernEnv } from "./config/index.js";
 export { AxernError, AxernRpcError, isNotFound, isCancelled, isUnavailable, errorRetryable, isPermissionDenied, isTimeout, rpcCode, SandboxExecError, SandboxStateError, SandboxTimeoutError, SandboxValidationError, } from "./errors/index.js";
-export { NodeSandboxClient } from "./node/client.js";
+export { AllocationClient } from "./node/client.js";
 export { SandboxProcess } from "./node/process.js";
 export { Sandbox } from "./sandbox/index.js";
 export { NetworkPolicy, cidrRule, portRange } from "./network-policy.js";
-export { workspaceMount } from "./types.js";
 export { AXERN_VERSION, platformName } from "./version.js";

package/dist/node/archive.js

@@ -8,7 +8,7 @@ import { nonEmptyPath } from "../validation.js";
 import { downloadArchiveStream, uploadArchiveStream } from "./streams.js";
 export async function uploadArchive(ctx, path, chunks, options = {}) {
     try {
-        await ctx.withAuthRetry(options.leaseTtlSeconds ?? 300, (client) => uploadArchiveStream(client, ctx.authRequest({
+        await ctx.withAuthRetry((client) => uploadArchiveStream(client, ctx.authRequest({
             path: nonEmptyPath(path),
             format: 1,
             create_parents: options.createParents ?? true,

package/dist/node/attached_process.d.ts

@@ -3,8 +3,7 @@
  * Copyright 2026 cofy-x
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { Command, ImageProcessOptions, ProcessOptions } from "../types.js";
+import type { Command, ProcessOptions } from "../types.js";
 import { NodeClientContext } from "./context.js";
 import { SandboxProcess } from "./process.js";
 export declare function process(ctx: NodeClientContext, command: Command, options?: ProcessOptions): Promise<SandboxProcess>;
-export declare function processImage(ctx: NodeClientContext, image: string, command: Command, options?: ImageProcessOptions): Promise<SandboxProcess>;

package/dist/node/attached_process.js

@@ -3,12 +3,13 @@
  * Copyright 2026 cofy-x
  * SPDX-License-Identifier: Apache-2.0
  */
-import { mapRpcError } from "../errors/index.js";
+import { mapRpcError, SandboxValidationError } from "../errors/index.js";
 import { normalizeCommand } from "../validation.js";
-import { execSpec, imageProcessSpec } from "./exec.js";
+import { execSpec } from "./exec.js";
 import { SandboxProcess } from "./process.js";
 export async function process(ctx, command, options = {}) {
     const argv = normalizeCommand(command);
+    const initialSize = processInitialSize(options);
     const client = ctx.rpcClient();
     const call = client
         .Process();
@@ -17,11 +18,12 @@ export async function process(ctx, command, options = {}) {
         call,
         closeClient: () => client.close(),
     });
-    call.write({
+    await new Promise((resolve, reject) => call.write({
         open: ctx.authRequest({
             spec: execSpec(argv, options),
+            ...(initialSize === undefined ? {} : { initial_size: initialSize }),
         }),
-    });
+    }, (error) => error == null ? resolve() : reject(error)));
     try {
         await sandboxProcess.waitReady();
         return sandboxProcess;
@@ -31,30 +33,14 @@ export async function process(ctx, command, options = {}) {
         throw mapRpcError(error, "sandbox process", ctx.allocationId);
     }
 }
-export async function processImage(ctx, image, command, options = {}) {
-    if (image.trim() === "") {
-        throw new Error("image is required");
-    }
-    const argv = normalizeCommand(command);
-    const client = ctx.rpcClient();
-    const call = client
-        .ProcessImage();
-    const sandboxProcess = new SandboxProcess({
-        allocationId: ctx.allocationId,
-        call,
-        closeClient: () => client.close(),
-    });
-    call.write({
-        open: ctx.authRequest({
-            spec: imageProcessSpec(image, argv, options),
-        }),
-    });
-    try {
-        await sandboxProcess.waitReady();
-        return sandboxProcess;
+function processInitialSize(options) {
+    const cols = options.initialCols ?? 0;
+    const rows = options.initialRows ?? 0;
+    if ((cols === 0) !== (rows === 0)) {
+        throw new SandboxValidationError("initialCols and initialRows must both be zero or both be positive");
     }
-    catch (error) {
-        await sandboxProcess.close();
-        throw mapRpcError(error, "sandbox image process", ctx.allocationId);
+    if (cols < 0 || rows < 0 || !Number.isInteger(cols) || !Number.isInteger(rows)) {
+        throw new SandboxValidationError("initialCols and initialRows must be non-negative integers");
     }
+    return cols === 0 ? undefined : { cols, rows };
 }

package/dist/node/capabilities.js

@@ -7,7 +7,7 @@ import { mapRpcError } from "../errors/index.js";
 import { unary } from "../generated/proto.js";
 export async function capabilityStatus(ctx, options = {}) {
     try {
-        const response = await ctx.withAuthRetry(60, (client) => unary(client, "CapabilityStatus", ctx.authRequest({}), options.rpcTimeoutMs));
+        const response = await ctx.withAuthRetry((client) => unary(client, "CapabilityStatus", ctx.authRequest({}), options.rpcTimeoutMs));
         return {
             ready: response.ready === true,
             capabilities: strings(response.capabilities),

package/dist/node/client.d.ts

@@ -4,22 +4,20 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import type * as grpc from "@grpc/grpc-js";
-import type { ChmodOptions, CapabilityStatus, Command, ComputerUseDisplay, ComputerUseKeyboardOptions, ComputerUseMouseOptions, ComputerUseScreenshot, ComputerUseScreenshotOptions, ComputerUseStatus, CopyOptions, DownloadArchiveOptions, ExecOptions, ExecResult, ImageExecOptions, ImageProcessOptions, MkdirOptions, MoveOptions, NodeCallOptions, ProcessOptions, RemoveOptions, SandboxFileInfo, TouchOptions, UploadArchiveOptions, WriteFileOptions } from "../types.js";
+import type { ChmodOptions, CapabilityStatus, Command, ComputerUseDisplay, ComputerUseKeyboardOptions, ComputerUseMouseOptions, ComputerUseScreenshot, ComputerUseScreenshotOptions, ComputerUseStatus, CopyOptions, DownloadArchiveOptions, ExecOptions, ExecResult, MkdirOptions, MoveOptions, NodeCallOptions, ProcessOptions, RemoveOptions, SandboxFileInfo, TouchOptions, UploadArchiveOptions, WriteFileOptions } from "../types.js";
 import type { SandboxProcess } from "./process.js";
-export interface NodeSandboxClientOptions {
+export interface AllocationClientOptions {
     allocationId: string;
     target: string;
     credentials: grpc.ChannelCredentials;
     channelOptions?: grpc.ChannelOptions;
 }
-export declare class NodeSandboxClient {
+export declare class AllocationClient {
     readonly allocationId: string;
     private readonly ctx;
-    constructor(options: NodeSandboxClientOptions);
+    constructor(options: AllocationClientOptions);
     exec(command: Command, options?: ExecOptions): Promise<ExecResult>;
     process(command: Command, options?: ProcessOptions): Promise<SandboxProcess>;
-    execImage(image: string, command: Command, options?: ImageExecOptions): Promise<ExecResult>;
-    processImage(image: string, command: Command, options?: ImageProcessOptions): Promise<SandboxProcess>;
     capabilityStatus(options?: NodeCallOptions): Promise<CapabilityStatus>;
     computerUseStatus(options?: NodeCallOptions): Promise<ComputerUseStatus>;
     computerUseScreenshot(options?: ComputerUseScreenshotOptions): Promise<ComputerUseScreenshot>;

package/dist/node/client.js

@@ -7,11 +7,10 @@ import { uploadArchive, downloadArchive } from "./archive.js";
 import { capabilityStatus } from "./capabilities.js";
 import * as computerUse from "./computer_use.js";
 import { process as startProcess } from "./attached_process.js";
-import { processImage as startImageProcess } from "./attached_process.js";
 import { NodeClientContext } from "./context.js";
-import { exec, execImage } from "./exec.js";
+import { exec } from "./exec.js";
 import * as files from "./files.js";
-export class NodeSandboxClient {
+export class AllocationClient {
     allocationId;
     ctx;
     constructor(options) {
@@ -24,12 +23,6 @@ export class NodeSandboxClient {
     async process(command, options = {}) {
         return startProcess(this.ctx, command, options);
     }
-    async execImage(image, command, options = {}) {
-        return execImage(this.ctx, image, command, options);
-    }
-    async processImage(image, command, options = {}) {
-        return startImageProcess(this.ctx, image, command, options);
-    }
     async capabilityStatus(options = {}) {
         return capabilityStatus(this.ctx, options);
     }

package/dist/node/computer_use.js

@@ -68,7 +68,7 @@ export async function computerUseKeyboard(ctx, options = {}) {
 }
 async function computerUseUnary(ctx, method, payload, rpcTimeoutMs) {
     try {
-        return await ctx.withAuthRetry(60, (client) => unary(client, method, ctx.authRequest(payload), rpcTimeoutMs));
+        return await ctx.withAuthRetry((client) => unary(client, method, ctx.authRequest(payload), rpcTimeoutMs));
     }
     catch (error) {
         throw mapRpcError(error, `sandbox ${method}`, ctx.allocationId);

package/dist/node/context.d.ts

@@ -16,7 +16,7 @@ export declare class NodeClientContext {
     private readonly credentials;
     private readonly channelOptions;
     constructor(options: NodeClientContextOptions);
-    withAuthRetry<T>(_leaseTtlSeconds: number, operation: (client: grpc.Client) => Promise<T>): Promise<T>;
+    withAuthRetry<T>(operation: (client: grpc.Client) => Promise<T>): Promise<T>;
     rpcClient(): grpc.Client;
     authRequest(payload: Record<string, unknown>): Record<string, unknown>;
 }

package/dist/node/context.js

@@ -15,7 +15,7 @@ export class NodeClientContext {
         this.credentials = options.credentials;
         this.channelOptions = options.channelOptions ?? {};
     }
-    async withAuthRetry(_leaseTtlSeconds, operation) {
+    async withAuthRetry(operation) {
         const client = this.rpcClient();
         try {
             return await operation(client);

package/dist/node/exec.d.ts

@@ -3,10 +3,8 @@
  * Copyright 2026 cofy-x
  * SPDX-License-Identifier: Apache-2.0
  */
-import type { Command, ExecOptions, ExecResult, ImageExecOptions, ImageProcessOptions, ProcessOptions } from "../types.js";
+import type { Command, ExecOptions, ExecResult, ProcessOptions } from "../types.js";
 import type { NodeClientContext } from "./context.js";
 export declare function exec(ctx: NodeClientContext, command: Command, options?: ExecOptions): Promise<ExecResult>;
-export declare function execImage(ctx: NodeClientContext, image: string, command: Command, options?: ImageExecOptions): Promise<ExecResult>;
 export declare function execSpec(argv: string[], options: ExecOptions | ProcessOptions): Record<string, unknown>;
-export declare function imageProcessSpec(image: string, argv: string[], options: ImageExecOptions | ImageProcessOptions): Record<string, unknown>;
 export declare function execResult(response: Record<string, unknown>): ExecResult;

package/dist/node/exec.js

@@ -9,7 +9,7 @@ import { normalizeCommand } from "../validation.js";
 export async function exec(ctx, command, options = {}) {
     const argv = normalizeCommand(command);
     try {
-        const response = await ctx.withAuthRetry(options.leaseTtlSeconds ?? 300, async (client) => unary(client, "Exec", ctx.authRequest({
+        const response = await ctx.withAuthRetry(async (client) => unary(client, "Exec", ctx.authRequest({
             spec: execSpec(argv, options),
         }), options.rpcTimeoutMs));
         const result = execResult(response);
@@ -25,28 +25,6 @@ export async function exec(ctx, command, options = {}) {
         throw mapRpcError(error, "sandbox exec", ctx.allocationId);
     }
 }
-export async function execImage(ctx, image, command, options = {}) {
-    if (image.trim() === "") {
-        throw new Error("image is required");
-    }
-    const argv = normalizeCommand(command);
-    try {
-        const response = await ctx.withAuthRetry(options.leaseTtlSeconds ?? 300, async (client) => unary(client, "ExecImage", ctx.authRequest({
-            spec: imageProcessSpec(image, argv, options),
-        }), options.rpcTimeoutMs));
-        const result = execResult(response);
-        if (options.check === true && result.exitCode !== 0) {
-            throw new SandboxExecError(argv, result);
-        }
-        return result;
-    }
-    catch (error) {
-        if (error instanceof SandboxExecError) {
-            throw error;
-        }
-        throw mapRpcError(error, "sandbox exec image", ctx.allocationId);
-    }
-}
 export function execSpec(argv, options) {
     return {
         argv,
@@ -57,27 +35,6 @@ export function execSpec(argv, options) {
         user: options.user ?? "",
     };
 }
-export function imageProcessSpec(image, argv, options) {
-    return {
-        image,
-        argv,
-        env: options.env ?? {},
-        cwd: options.cwd ?? "",
-        timeout_seconds: options.timeoutSeconds ?? 0,
-        tty: options.tty ?? false,
-        user: options.user ?? "",
-        mounts: imageProcessMounts(options.mounts),
-    };
-}
-function imageProcessMounts(mounts) {
-    const effective = mounts ?? [{ sandboxPath: "/workspace", targetPath: "/workspace" }];
-    return effective.map((mount) => ({
-        sandbox_path: mount.sandboxPath,
-        target_path: mount.targetPath,
-        readonly: mount.readonly ?? false,
-        options: [...(mount.options ?? [])],
-    }));
-}
 export function execResult(response) {
     const stdout = Buffer.from(response.stdout ?? []);
     const stderr = Buffer.from(response.stderr ?? []);

package/dist/node/files.js

@@ -70,7 +70,7 @@ export async function touch(ctx, path, options = {}) {
 }
 async function fileUnary(ctx, method, payload) {
     try {
-        return await ctx.withAuthRetry(300, (client) => unary(client, method, ctx.authRequest(payload)));
+        return await ctx.withAuthRetry((client) => unary(client, method, ctx.authRequest(payload)));
     }
     catch (error) {
         throw mapRpcError(error, `sandbox ${method}`, ctx.allocationId);

package/dist/node/process.d.ts

@@ -19,18 +19,23 @@ export declare class SandboxProcess {
     private error;
     private ended;
     private exit?;
+    private paused;
+    private closed;
+    private static readonly maxQueuedEvents;
+    private static readonly resumeQueuedEvents;
     constructor(options: SandboxProcessOptions);
-    write(data: Buffer | Uint8Array | string): void;
-    closeStdin(): void;
-    resize(cols: number, rows: number): void;
-    signal(signal: string): void;
-    terminate(): void;
-    kill(): void;
+    write(data: Buffer | Uint8Array | string): Promise<void>;
+    closeStdin(): Promise<void>;
+    resize(cols: number, rows: number): Promise<void>;
+    signal(signal: string): Promise<void>;
+    terminate(): Promise<void>;
+    kill(): Promise<void>;
     waitReady(): Promise<void>;
     wait(): Promise<ProcessResult>;
     close(): Promise<void>;
     events(): AsyncIterable<ProcessEvent>;
     private nextEvent;
     private enqueue;
+    private writeRequest;
     private finish;
 }

package/dist/node/process.js

@@ -13,6 +13,10 @@ export class SandboxProcess {
     error;
     ended = false;
     exit;
+    paused = false;
+    closed = false;
+    static maxQueuedEvents = 64;
+    static resumeQueuedEvents = 32;
     constructor(options) {
         this.allocationId = options.allocationId;
         this.call = options.call;
@@ -25,22 +29,22 @@ export class SandboxProcess {
         this.call.on("end", () => this.finish());
     }
     write(data) {
-        this.call.write({ stdin: Buffer.isBuffer(data) ? data : Buffer.from(data) });
+        return this.writeRequest({ stdin: Buffer.isBuffer(data) ? data : Buffer.from(data) });
     }
     closeStdin() {
-        this.call.write({ close_stdin: true });
+        return this.writeRequest({ close_stdin: true });
     }
     resize(cols, rows) {
-        this.call.write({ resize: { cols, rows } });
+        return this.writeRequest({ resize: { cols, rows } });
     }
     signal(signal) {
-        this.call.write({ signal: { signal } });
+        return this.writeRequest({ signal: { signal } });
     }
     terminate() {
-        this.signal("TERM");
+        return this.signal("TERM");
     }
     kill() {
-        this.signal("KILL");
+        return this.signal("KILL");
     }
     async waitReady() {
         const next = await this.nextEvent();
@@ -69,7 +73,14 @@ export class SandboxProcess {
         throw new Error("sandbox process stream ended before exit");
     }
     async close() {
+        if (this.closed)
+            return;
+        if (!this.ended && this.exit === undefined) {
+            await this.terminate().catch(() => undefined);
+        }
+        this.closed = true;
         this.call.end();
+        this.call.cancel();
         this.closeClient();
     }
     async *events() {
@@ -90,6 +101,10 @@ export class SandboxProcess {
     nextEvent() {
         const event = this.queue.shift();
         if (event !== undefined) {
+            if (this.paused && this.queue.length <= SandboxProcess.resumeQueuedEvents) {
+                this.paused = false;
+                this.call.resume();
+            }
             return Promise.resolve({ done: false, value: event });
         }
         if (this.ended) {
@@ -108,8 +123,32 @@ export class SandboxProcess {
             waiter({ done: false, value: event });
         }
         else {
+            if (this.queue.length >= SandboxProcess.maxQueuedEvents) {
+                this.error = new Error("sandbox process consumer is too slow; event queue limit exceeded");
+                this.call.cancel();
+                this.finish();
+                return;
+            }
             this.queue.push(event);
+            if (!this.paused && this.queue.length >= SandboxProcess.maxQueuedEvents) {
+                this.paused = true;
+                this.call.pause();
+            }
+        }
+    }
+    writeRequest(request) {
+        if (this.closed || this.ended) {
+            return Promise.reject(new Error("sandbox process stream is closed"));
         }
+        return new Promise((resolve, reject) => {
+            this.call.write(request, (error) => {
+                if (error !== undefined && error !== null) {
+                    reject(mapRpcError(error, "sandbox process write", this.allocationId));
+                    return;
+                }
+                resolve();
+            });
+        });
     }
     finish() {
         if (this.ended) {

package/dist/proto/axern/control/admin/v1/access.proto

@@ -30,7 +30,12 @@ enum AccessRole {
   ACCESS_ROLE_NAMESPACE_ADMIN = 2;
   ACCESS_ROLE_NAMESPACE_EDITOR = 3;
   ACCESS_ROLE_NAMESPACE_VIEWER = 4;
-  ACCESS_ROLE_ROLLOUT_EXECUTOR = 5;
+}
+
+enum CredentialKind {
+  CREDENTIAL_KIND_UNSPECIFIED = 0;
+  CREDENTIAL_KIND_X509 = 1;
+  CREDENTIAL_KIND_SSH = 2;
 }
 
 message Principal {
@@ -39,19 +44,19 @@ message Principal {
   string display_name = 3;
   PrincipalKind kind = 4;
   PrincipalStatus status = 5;
-  int64 version = 6;
-  google.protobuf.Timestamp created_at = 7;
-  google.protobuf.Timestamp updated_at = 8;
+  google.protobuf.Timestamp created_at = 6;
+  google.protobuf.Timestamp updated_at = 7;
 }
 
 message PrincipalCredential {
   string credential_id = 1;
   string principal_id = 2;
   string fingerprint = 3;
-  google.protobuf.Timestamp certificate_not_after = 4;
+  google.protobuf.Timestamp expires_at = 4;
   string label = 5;
   google.protobuf.Timestamp created_at = 6;
   google.protobuf.Timestamp revoked_at = 7;
+  CredentialKind kind = 8;
 }
 
 message RoleBinding {
@@ -83,6 +88,8 @@ message AddPrincipalCredentialRequest {
   string principal_id = 1;
   bytes certificate_der = 2;
   string label = 3;
+  string ssh_public_key = 4;
+  google.protobuf.Timestamp expires_at = 5;
 }
 message AddPrincipalCredentialResponse { PrincipalCredential credential = 1; }
 

package/dist/proto/axern/control/admin/v1/audit.proto

@@ -11,27 +11,25 @@ enum AdminAuditOperation {
   ADMIN_AUDIT_OPERATION_FORCE_ALLOCATION_LIFECYCLE_RETRY = 1;
   ADMIN_AUDIT_OPERATION_FAIL_ALLOCATION_LIFECYCLE_RETRY = 2;
   ADMIN_AUDIT_OPERATION_CLEAR_ALLOCATION_LIFECYCLE_RETRY = 3;
-  ADMIN_AUDIT_OPERATION_RETRY_STORAGE_BINDING = 4;
-  ADMIN_AUDIT_OPERATION_PURGE_SERVICE = 5;
-  ADMIN_AUDIT_OPERATION_RETIRE_NODE = 6;
-  ADMIN_AUDIT_OPERATION_CREATE_PRINCIPAL = 7;
-  ADMIN_AUDIT_OPERATION_DISABLE_PRINCIPAL = 8;
-  ADMIN_AUDIT_OPERATION_ADD_CREDENTIAL = 9;
-  ADMIN_AUDIT_OPERATION_REVOKE_CREDENTIAL = 10;
-  ADMIN_AUDIT_OPERATION_GRANT_ROLE_BINDING = 11;
-  ADMIN_AUDIT_OPERATION_REVOKE_ROLE_BINDING = 12;
-  ADMIN_AUDIT_OPERATION_BOOTSTRAP_ACCESS = 13;
+  ADMIN_AUDIT_OPERATION_RETIRE_NODE = 4;
+  ADMIN_AUDIT_OPERATION_CREATE_PRINCIPAL = 5;
+  ADMIN_AUDIT_OPERATION_DISABLE_PRINCIPAL = 6;
+  ADMIN_AUDIT_OPERATION_ADD_CREDENTIAL = 7;
+  ADMIN_AUDIT_OPERATION_REVOKE_CREDENTIAL = 8;
+  ADMIN_AUDIT_OPERATION_GRANT_ROLE_BINDING = 9;
+  ADMIN_AUDIT_OPERATION_REVOKE_ROLE_BINDING = 10;
+  ADMIN_AUDIT_OPERATION_BOOTSTRAP_ACCESS = 11;
+  ADMIN_AUDIT_OPERATION_ADMIT_NODE = 12;
+  ADMIN_AUDIT_OPERATION_REVOKE_NODE = 13;
 }
 
 enum AdminAuditTargetType {
   ADMIN_AUDIT_TARGET_TYPE_UNSPECIFIED = 0;
   ADMIN_AUDIT_TARGET_TYPE_ALLOCATION = 1;
-  ADMIN_AUDIT_TARGET_TYPE_STORAGE_BINDING = 2;
-  ADMIN_AUDIT_TARGET_TYPE_SERVICE = 3;
-  ADMIN_AUDIT_TARGET_TYPE_NODE = 4;
-  ADMIN_AUDIT_TARGET_TYPE_PRINCIPAL = 5;
-  ADMIN_AUDIT_TARGET_TYPE_CREDENTIAL = 6;
-  ADMIN_AUDIT_TARGET_TYPE_ROLE_BINDING = 7;
+  ADMIN_AUDIT_TARGET_TYPE_NODE = 2;
+  ADMIN_AUDIT_TARGET_TYPE_PRINCIPAL = 3;
+  ADMIN_AUDIT_TARGET_TYPE_CREDENTIAL = 4;
+  ADMIN_AUDIT_TARGET_TYPE_ROLE_BINDING = 5;
 }
 
 message AdminAuditEvent {