@gitterm/sdk 0.0.1 → 0.0.4

package/dist/index.js

@@ -62,6 +62,43 @@ class GittermError extends Error {
   }
 }
 
+class WorkspaceLifecycleError extends GittermError {
+  constructor(code, message, options = {}) {
+    super(code, message, options);
+    this.name = "WorkspaceLifecycleError";
+  }
+}
+
+// src/transport.ts
+var LOOPBACK_HOSTS = new Set(["localhost", "127.0.0.1", "[::1]", "::1"]);
+function normalizeServerUrl(value) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`Invalid GitTerm server URL: ${value}`);
+  }
+  if (url.username || url.password) {
+    throw new Error("GitTerm server URL must not contain credentials");
+  }
+  if (url.protocol !== "https:" && !(url.protocol === "http:" && LOOPBACK_HOSTS.has(url.hostname))) {
+    throw new Error("GitTerm server URL must use HTTPS (HTTP is allowed only for loopback)");
+  }
+  url.hash = "";
+  url.search = "";
+  return url.toString().replace(/\/$/, "");
+}
+function createNoRedirectFetch(fetchImpl = fetch) {
+  return async (input, init) => {
+    const response = await fetchImpl(input, { ...init, redirect: "manual" });
+    if (response.status >= 300 && response.status < 400) {
+      const location = response.headers.get("location");
+      throw new Error(location ? `GitTerm server redirects are not allowed: ${location}` : "GitTerm server redirects are not allowed");
+    }
+    return response;
+  };
+}
+
 // src/client.ts
 function envValue(name) {
   const value = typeof process !== "undefined" ? process.env[name] : undefined;
@@ -69,12 +106,12 @@ function envValue(name) {
 }
 function resolveCredentials(options) {
   const config = !options.serverUrl || !options.token ? loadConfigSync(options.configPath) : null;
-  const serverUrl = options.serverUrl ?? envValue("GITTERM_SERVER_URL") ?? config?.serverUrl;
+  const serverUrl = options.serverUrl ?? envValue("GITTERM_SERVER_URL") ?? config?.serverUrl ?? DEFAULT_GITTERM_SERVER_URL;
   const token = options.token ?? envValue("GITTERM_API_TOKEN") ?? config?.token;
   if (!serverUrl || !token) {
     throw new GittermError("NOT_LOGGED_IN", "Not logged in. Run: gitterm login");
   }
-  return { serverUrl, token };
+  return { serverUrl: normalizeServerUrl(serverUrl), token };
 }
 function toTrpcUrl(serverUrl) {
   return new URL("/trpc", serverUrl).toString();
@@ -121,7 +158,7 @@ function normalizeWorkspace(workspace) {
       imageId: workspace.image.imageId
     } : null,
     startedAt: toIso(workspace.startedAt),
-    stoppedAt: toIso(workspace.stoppedAt),
+    pausedAt: toIso(workspace.pausedAt),
     terminatedAt: toIso(workspace.terminatedAt),
     lastActiveAt: toIso(workspace.lastActiveAt),
     updatedAt: toIso(workspace.updatedAt)
@@ -154,6 +191,8 @@ function mapTrpcCode(code) {
       return "FORBIDDEN";
     case "BAD_REQUEST":
       return "BAD_REQUEST";
+    case "CONFLICT":
+      return "CONFLICT";
     default:
       return "SERVER_ERROR";
   }
@@ -172,6 +211,24 @@ async function runWithServer(serverUrl, operation) {
         });
       }
       const code = mapTrpcCode(trpcCode);
+      if (/WORKSPACE_TERMINATED/.test(error.message)) {
+        throw new WorkspaceLifecycleError("WORKSPACE_TERMINATED", error.message, { cause: error });
+      }
+      if (/WORKSPACE_NON_RECOVERABLE/.test(error.message)) {
+        throw new WorkspaceLifecycleError("WORKSPACE_NON_RECOVERABLE", error.message, {
+          cause: error
+        });
+      }
+      if (/WORKSPACE_START_TIMEOUT/.test(error.message)) {
+        throw new WorkspaceLifecycleError("WORKSPACE_START_TIMEOUT", error.message, {
+          cause: error
+        });
+      }
+      if (/WORKSPACE_RESTART_FAILED/.test(error.message)) {
+        throw new WorkspaceLifecycleError("WORKSPACE_RESTART_FAILED", error.message, {
+          cause: error
+        });
+      }
       throw new GittermError(code, code === "UNAUTHORIZED" ? "Not logged in or token expired. Run: gitterm login" : error.message, { cause: error });
     }
     throw new GittermError("NETWORK", error instanceof Error ? error.message : "Network request failed", { cause: error });
@@ -183,14 +240,13 @@ function createGittermClient(options = {}) {
     links: [
       httpBatchLink({
         url: toTrpcUrl(credentials.serverUrl),
-        fetch: options.fetch,
+        fetch: createNoRedirectFetch(options.fetch),
         headers: () => ({ authorization: `Bearer ${credentials.token}` })
       })
     ]
   });
   const run = (operation) => runWithServer(credentials.serverUrl, operation);
-  const createWorkspace = (input) => run(async () => {
-    const result = await trpc.workspace.createWorkspace.mutate(input);
+  const normalizeCreateResult = (result) => {
     const workspace = normalizeWorkspace(result.workspace);
     if (!workspace)
       throw new GittermError("SERVER_ERROR", "Workspace creation failed");
@@ -208,7 +264,30 @@ function createGittermClient(options = {}) {
       providerKey: null
     };
     return { workspace, runtime };
+  };
+  const createWorkspace = (input) => run(async () => {
+    const result = await trpc.workspace.createWorkspace.mutate(input);
+    return normalizeCreateResult(result);
   });
+  const waitForWorkspaceSetup = async (workspaceId, waitOptions) => {
+    const timeoutMs = waitOptions?.timeoutMs ?? 10 * 60000;
+    const pollIntervalMs = waitOptions?.pollIntervalMs ?? 2000;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const result = await trpc.workspace.getSetupStatus.query({ workspaceId });
+      if (result.status === "not_requested" || result.status === "succeeded")
+        return result;
+      if (result.status === "failed") {
+        const log = result.log?.trim();
+        throw new GittermError("BAD_REQUEST", `Workspace setup failed${result.exitCode === null ? "" : ` with exit code ${result.exitCode}`}${log ? `
+${log}` : ""}`);
+      }
+      if (Date.now() >= deadline) {
+        throw new GittermError("NETWORK", `Timed out waiting for workspace ${workspaceId} setup`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+    }
+  };
   return {
     serverUrl: credentials.serverUrl,
     auth: {
@@ -273,7 +352,28 @@ function createGittermClient(options = {}) {
         };
       }),
       create: createWorkspace,
-      createSandbox: createWorkspace
+      setupStatus: (workspaceId) => run(async () => trpc.workspace.getSetupStatus.query({ workspaceId })),
+      waitForSetup: (workspaceId, waitOptions) => run(() => waitForWorkspaceSetup(workspaceId, waitOptions))
+    },
+    runs: {
+      create: (input) => run(async () => trpc.run.create.mutate(input)),
+      get: (workspaceId, runId) => run(async () => trpc.run.get.query({ workspaceId, runId })),
+      messages: (workspaceId, runId) => run(async () => trpc.run.messages.query({ workspaceId, runId })),
+      cancel: (workspaceId, runId) => run(async () => trpc.run.cancel.mutate({ workspaceId, runId })),
+      wait: (workspaceId, runId, waitOptions) => run(async () => {
+        const timeoutMs = waitOptions?.timeoutMs ?? 30 * 60000;
+        const pollIntervalMs = waitOptions?.pollIntervalMs ?? 2000;
+        const deadline = Date.now() + timeoutMs;
+        while (true) {
+          const result = await trpc.run.get.query({ workspaceId, runId });
+          if (result.status !== "pending" && result.status !== "running" && result.status !== "retrying")
+            return result;
+          if (Date.now() >= deadline) {
+            throw new GittermError("NETWORK", `Timed out waiting for run ${runId}`);
+          }
+          await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
+        }
+      })
     },
     catalog: {
       agentTypes: (input) => run(async () => {
@@ -283,7 +383,8 @@ function createGittermClient(options = {}) {
       cloudProviders: (input) => run(async () => {
         const result = await trpc.workspace.listCloudProviders.query(input);
         return result.cloudProviders;
-      })
+      }),
+      workspaceOptions: () => run(async () => trpc.workspace.getWorkspaceCatalog.query())
     }
   };
 }
@@ -292,8 +393,9 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 async function loginWithDeviceCode(serverUrl, options = {}) {
-  const fetchImpl = options.fetch ?? fetch;
-  const codeRes = await fetchImpl(new URL("/api/device/code", serverUrl), {
+  const normalizedServerUrl = normalizeServerUrl(serverUrl);
+  const fetchImpl = createNoRedirectFetch(options.fetch);
+  const codeRes = await fetchImpl(new URL("/api/device/code", normalizedServerUrl), {
     method: "POST",
     headers: { "content-type": "application/json" },
     body: JSON.stringify({ clientName: options.clientName ?? "gitterm" })
@@ -309,7 +411,7 @@ async function loginWithDeviceCode(serverUrl, options = {}) {
   });
   const deadline = Date.now() + codeJson.expiresInSeconds * 1000;
   while (Date.now() < deadline) {
-    const tokenRes = await fetchImpl(new URL("/api/device/token", serverUrl), {
+    const tokenRes = await fetchImpl(new URL("/api/device/token", normalizedServerUrl), {
       method: "POST",
       headers: { "content-type": "application/json" },
       body: JSON.stringify({ deviceCode: codeJson.deviceCode })
@@ -326,14 +428,78 @@ async function loginWithDeviceCode(serverUrl, options = {}) {
   }
   throw new Error("Device code expired; try again.");
 }
+// src/workspace-client.ts
+import { TRPCClientError as TRPCClientError2, createTRPCClient as createTRPCClient2, httpBatchLink as httpBatchLink2 } from "@trpc/client";
+function getWorkspaceEnvironment(environment) {
+  environment ??= typeof process === "undefined" ? {} : process.env;
+  const serverUrl = environment.WORKSPACE_API_URL;
+  const token = environment.WORKSPACE_AUTH_TOKEN;
+  const workspaceId = environment.WORKSPACE_ID;
+  const workspaceEnvironmentPresent = Boolean(serverUrl || token || workspaceId);
+  if (!workspaceEnvironmentPresent)
+    return null;
+  if (!serverUrl || !token || !workspaceId) {
+    throw new GittermError("UNAUTHORIZED", "Incomplete GitTerm workspace environment: WORKSPACE_API_URL, WORKSPACE_AUTH_TOKEN, and WORKSPACE_ID are required");
+  }
+  return { serverUrl: normalizeServerUrl(serverUrl), token, workspaceId };
+}
+function errorCode(code) {
+  if (code === "UNAUTHORIZED" || code === "NOT_FOUND" || code === "FORBIDDEN")
+    return code;
+  if (code === "BAD_REQUEST")
+    return code;
+  return "SERVER_ERROR";
+}
+function createGittermWorkspaceClient(options = {}) {
+  const detected = options.serverUrl && options.token && options.workspaceId ? null : getWorkspaceEnvironment();
+  const rawServerUrl = options.serverUrl ?? detected?.serverUrl;
+  const token = options.token ?? detected?.token;
+  const workspaceId = options.workspaceId ?? detected?.workspaceId;
+  if (!rawServerUrl || !token || !workspaceId) {
+    throw new GittermError("UNAUTHORIZED", "This command must run inside a GitTerm workspace");
+  }
+  const serverUrl = normalizeServerUrl(rawServerUrl);
+  const trpc = createTRPCClient2({
+    links: [
+      httpBatchLink2({
+        url: new URL("/trpc", serverUrl).toString(),
+        fetch: createNoRedirectFetch(options.fetch),
+        headers: () => ({ authorization: `Bearer ${token}` })
+      })
+    ]
+  });
+  async function run(operation) {
+    try {
+      return await operation();
+    } catch (error) {
+      if (error instanceof TRPCClientError2) {
+        throw new GittermError(errorCode(error.data?.code), error.message, { cause: error });
+      }
+      throw new GittermError("NETWORK", error instanceof Error ? error.message : "Network request failed", { cause: error });
+    }
+  }
+  return {
+    workspaceId,
+    serverUrl,
+    self: { get: () => run(() => trpc.workspaceOps.getSelf.query()) },
+    ports: {
+      list: () => run(() => trpc.workspaceOps.listPorts.query()),
+      open: (port, input) => run(() => trpc.workspaceOps.openPort.mutate({ port, ...input })),
+      close: (port) => run(() => trpc.workspaceOps.closePort.mutate({ port }))
+    }
+  };
+}
 export {
   saveConfig,
   loginWithDeviceCode,
   loadConfigSync,
   loadConfig,
+  getWorkspaceEnvironment,
   getConfigPath,
   deleteConfig,
+  createGittermWorkspaceClient,
   createGittermClient,
+  WorkspaceLifecycleError,
   GittermError,
   DEFAULT_GITTERM_SERVER_URL
 };

package/dist/transport.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeServerUrl(value: string): string;
+export declare function createNoRedirectFetch(fetchImpl?: typeof fetch): typeof fetch;

package/dist/types.d.ts

@@ -0,0 +1,297 @@
+export type AuthStatus = {
+    loggedIn: true;
+    userId: string;
+    email: string;
+    name: string;
+    plan: string;
+    authMethod: "session" | "apiToken";
+};
+export type WorkspaceStatus = "pending" | "running" | "paused" | "terminated";
+export type WorkspaceHostingType = "cloud" | "local";
+export type Workspace = {
+    id: string;
+    name: string | null;
+    status: WorkspaceStatus;
+    repositoryUrl: string | null;
+    repositoryBranch: string | null;
+    baseCommit: string | null;
+    checkoutRef: string | null;
+    domain: string;
+    subdomain: string | null;
+    persistent: boolean;
+    hostingType: WorkspaceHostingType;
+    serverOnly: boolean;
+    workspaceProfile: string;
+    cloudProviderId: string;
+    agentType: {
+        id: string;
+        name: string;
+        description: string | null;
+    } | null;
+    image: {
+        id: string;
+        name: string;
+        imageId: string;
+    } | null;
+    startedAt: string | null;
+    pausedAt: string | null;
+    terminatedAt: string | null;
+    lastActiveAt: string | null;
+    updatedAt: string | null;
+};
+export type WorkspaceRuntimeAccess = {
+    workspaceId: string;
+    status: WorkspaceStatus;
+    url: string | null;
+    headers?: Record<string, string>;
+    password?: string;
+    directory: string;
+    repo: string | null;
+    branch: string | null;
+    baseCommit: string | null;
+    checkoutRef: string | null;
+    persistent: boolean;
+    recoverable: boolean;
+    providerKey: string | null;
+};
+export type WorkspaceCreateResult = {
+    workspace: Workspace;
+    runtime: WorkspaceRuntimeAccess;
+};
+export type WorkspaceListOptions = {
+    limit?: number;
+    offset?: number;
+    status?: "all" | "active" | "terminated";
+};
+export type WorkspaceListResult = {
+    workspaces: Workspace[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+    };
+};
+export type ProviderKey = "railway" | "aws" | "e2b" | "daytona" | "cloudflare" | "vercel" | "ascii" | "exedev";
+type ProviderSelectionBase = {
+    /** Select a specific provider installation. Usually omitted. */
+    providerId?: string;
+    /** An admin-defined profile or flexible resources within the provider's allowed limits. */
+    machine?: {
+        type: "profile";
+        key: string;
+    };
+};
+type FlexibleMachine<T> = {
+    type: "profile";
+    key: string;
+} | {
+    type: "custom";
+    resources: T;
+};
+type AwsResources = {
+    cpu?: number;
+    memory?: number;
+    ephemeralStorageGiB?: number;
+    architecture?: "X86_64" | "ARM64";
+};
+type DaytonaResources = {
+    resources?: {
+        cpu?: number;
+        memory?: number;
+        disk?: number;
+    };
+    editorResources?: {
+        cpu?: number;
+        memory?: number;
+        disk?: number;
+    };
+};
+type VercelResources = {
+    vcpus?: number;
+};
+type ExeDevResources = {
+    cpu?: number;
+    memory?: string;
+    disk?: string;
+};
+export type WorkspaceProviderSelection = {
+    type: "railway";
+    providerId?: string;
+    region?: string;
+} | ({
+    type: "aws";
+    region?: string;
+} & Omit<ProviderSelectionBase, "machine"> & {
+    machine?: FlexibleMachine<AwsResources>;
+}) | ({
+    type: "daytona";
+} & Omit<ProviderSelectionBase, "machine"> & {
+    machine?: FlexibleMachine<DaytonaResources>;
+}) | ({
+    type: "vercel";
+} & Omit<ProviderSelectionBase, "machine"> & {
+    machine?: FlexibleMachine<VercelResources>;
+}) | ({
+    type: "exedev";
+} & Omit<ProviderSelectionBase, "machine"> & {
+    machine?: FlexibleMachine<ExeDevResources>;
+}) | ({
+    type: "e2b" | "ascii";
+} & ProviderSelectionBase) | {
+    type: "cloudflare";
+    providerId?: string;
+};
+export type BuiltInAgentKey = "opencode-ttyd" | "opencode" | "t3code";
+export type AgentKey = BuiltInAgentKey | (string & {});
+export type WorkspaceCreateInput = {
+    idempotencyKey?: string;
+    name?: string;
+    repo: string;
+    branch?: string;
+    baseCommit?: string;
+    checkoutRef?: string;
+    subdomain?: string;
+    /** Stable agent key. Defaults to `opencode`. */
+    agent?: AgentKey;
+    /** Provider intent. Defaults to the user's or deployment's preferred provider. */
+    provider?: WorkspaceProviderSelection;
+    gitIntegrationId?: string;
+    /** Defaults from the selected provider. */
+    persistent?: boolean;
+    workspaceProfile?: "standard" | "ssh-enabled";
+    modelCredentialIds?: string[];
+    /**
+     * Ordered commands launched in the repository after the agent server starts.
+     * They do not block workspace readiness; inspect ~/.gitterm/setup for status
+     * and logs through workspaces.setupStatus()/waitForSetup().
+     */
+    setupCommands?: string[];
+    /** OpenCode capabilities materialized only in this workspace. */
+    opencode?: {
+        skills?: Array<{
+            name: string;
+            content: string;
+        }>;
+        /** NPM package specs or plugin paths accepted by OpenCode. Pin versions for repeatable runs. */
+        plugins?: string[];
+    };
+};
+export type WorkspaceRestartResult = {
+    status: WorkspaceStatus;
+};
+export type WorkspacePauseResult = {
+    durationMinutes: number;
+};
+export type WorkspaceTerminateResult = {
+    workspace: Workspace | null;
+    cleanupInBackground: boolean;
+};
+export type WorkspaceEnsureRunningResult = {
+    workspace: Workspace;
+    runtime: WorkspaceRuntimeAccess;
+};
+export type AgentRunStatus = "pending" | "running" | "retrying" | "completed" | "failed" | "cancelled";
+export type AgentRun = {
+    id: string;
+    workspaceId: string;
+    title: string;
+    status: AgentRunStatus;
+    error: string | null;
+    finalText: string | null;
+    context: {
+        type: "isolated";
+    } | {
+        type: "continued";
+        runId: string;
+    };
+};
+export type AgentRunCreateInput = {
+    workspaceId: string;
+    /** Stable key used to return the same run when a request is retried. */
+    idempotencyKey: string;
+    prompt: string;
+    title?: string;
+    agent?: string;
+    /** OpenCode model in provider/model format. */
+    model?: string;
+    /** Start with fresh context (default), or continue a terminal run's context. */
+    context?: {
+        type: "isolated";
+    } | {
+        type: "continue";
+        runId: string;
+    };
+    /** Wait for workspace setup commands before submitting the prompt. */
+    waitForSetup?: boolean;
+    setupTimeoutMs?: number;
+};
+export type AgentRunMessage = {
+    id: string;
+    role: "user" | "assistant";
+    createdAt: string;
+    completedAt: string | null;
+    text: string;
+    error: string | null;
+};
+export type WorkspaceSetupStatus = {
+    status: "not_requested" | "waiting" | "running" | "succeeded" | "failed";
+    exitCode: number | null;
+    startedAt: string | null;
+    finishedAt: string | null;
+    log: string | null;
+};
+export type AgentType = {
+    id: string;
+    key: string;
+    name: string;
+    description: string | null;
+    serverOnly: boolean;
+    isEnabled: boolean;
+    createdAt: Date | string;
+    updatedAt: Date | string;
+};
+export type CloudProvider = {
+    id: string;
+    name: string;
+    providerKey: ProviderKey | string;
+    regions?: Array<{
+        id: string;
+        name: string;
+        location: string;
+        externalRegionIdentifier: string;
+    }>;
+};
+export type WorkspaceCatalog = {
+    agents: Array<{
+        id: string;
+        key: string;
+        name: string;
+        description: string | null;
+        serverOnly: boolean;
+    }>;
+    providers: Array<{
+        id: string;
+        type: ProviderKey;
+        name: string;
+        isDefault: boolean;
+        persistence: "required" | "optional" | "unsupported";
+        regionSelection: "none" | "user" | "admin";
+        regions: Array<{
+            id: string;
+            key: string;
+            name: string;
+            location: string;
+        }>;
+        machines: Array<{
+            id: string;
+            key: string;
+            name: string;
+            description: string | null;
+            isDefault: boolean;
+        }>;
+        agentKeys: string[];
+        ssh: boolean;
+    }>;
+};
+export {};

package/dist/workspace-client.d.ts

@@ -0,0 +1,44 @@
+export type WorkspaceEnvironment = {
+    serverUrl: string;
+    token: string;
+    workspaceId: string;
+};
+export type WorkspaceSelf = {
+    id: string;
+    name: string | null;
+    status: "pending" | "running" | "paused" | "terminated";
+    repositoryUrl: string | null;
+    repositoryBranch: string | null;
+    baseCommit: string | null;
+    checkoutRef: string | null;
+    providerKey: string | null;
+    url: string | null;
+    ports: WorkspacePort[];
+};
+export type WorkspacePort = {
+    port: number;
+    name: string | null;
+    url: string | null;
+};
+export type WorkspaceClientOptions = Partial<WorkspaceEnvironment> & {
+    fetch?: typeof globalThis.fetch;
+};
+export type GittermWorkspaceClient = {
+    workspaceId: string;
+    serverUrl: string;
+    self: {
+        get(): Promise<WorkspaceSelf>;
+    };
+    ports: {
+        list(): Promise<WorkspacePort[]>;
+        open(port: number, options?: {
+            name?: string;
+        }): Promise<WorkspacePort>;
+        close(port: number): Promise<{
+            port: number;
+            closed: boolean;
+        }>;
+    };
+};
+export declare function getWorkspaceEnvironment(environment?: Record<string, string | undefined>): WorkspaceEnvironment | null;
+export declare function createGittermWorkspaceClient(options?: WorkspaceClientOptions): GittermWorkspaceClient;

package/package.json

@@ -1,15 +1,14 @@
 {
   "name": "@gitterm/sdk",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "files": [
-    "dist",
-    "src/index.d.ts"
+    "dist"
   ],
   "type": "module",
   "exports": {
     ".": {
-      "types": "./src/index.d.ts",
-      "bun": "./src/index.ts",
+      "types": "./dist/index.d.ts",
+      "bun": "./dist/index.js",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
     }
@@ -18,7 +17,7 @@
     "access": "public"
   },
   "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target node --format esm --external @trpc/client && cp src/index.d.ts dist/index.d.ts",
+    "build": "rm -rf dist && bun build src/index.ts --outdir dist --target node --format esm --external @trpc/client && tsc -p tsconfig.build.json",
     "prepublishOnly": "bun run check-types && bun run build",
     "check-types": "tsc --noEmit"
   },
@@ -27,7 +26,6 @@
   },
   "devDependencies": {
     "@gitterm/api": "workspace:*",
-    "@gitterm/config": "workspace:*",
     "@trpc/server": "catalog:",
     "@types/bun": "^1.2.6",
     "typescript": "^5.8.2"