@miosa/sdk 2.0.5 → 2.0.7

package/dist/index.js

@@ -168,7 +168,7 @@ var TokenRefreshFailedError = class extends MiosaError {
 };
 
 // src/version.ts
-var SDK_VERSION = "2.0.5";
+var SDK_VERSION = "2.0.7";
 var SDK_USER_AGENT = `@miosa/sdk/${SDK_VERSION}`;
 
 // src/http.ts
@@ -302,8 +302,9 @@ var HttpClient = class {
           return new Uint8Array(buffer);
         }
         if (response.status === 204) {
-          return void 0;
+          return options.rawResponse ? response : void 0;
         }
+        if (options.rawResponse) return response;
         return await response.json();
       } catch (err) {
         clearTimeout(timer);
@@ -6799,6 +6800,385 @@ var Functions = class {
     return data ?? {};
   }
 };
+
+// src/resources/forge.ts
+var REPOSITORY_VISIBILITIES = /* @__PURE__ */ new Set([
+  "public",
+  "private",
+  "internal"
+]);
+var REPOSITORY_STATES = /* @__PURE__ */ new Set([
+  "provisioning",
+  "active",
+  "error",
+  "deletion_pending",
+  "deleted"
+]);
+var ForgeContractError = class extends MiosaError {
+  constructor(message, details) {
+    super(message, 502, "FORGE_CONTRACT_ERROR", details);
+    this.name = "ForgeContractError";
+  }
+};
+var ForgeUnavailableError = class extends MiosaError {
+  constructor(message, cause) {
+    super(message, cause.status, "FORGE_DISABLED", cause.details, cause.requestId);
+    this.name = "ForgeUnavailableError";
+  }
+};
+var ForgeStorageError = class extends MiosaError {
+  constructor(message, cause) {
+    super(message, cause.status, cause.code, cause.details, cause.requestId);
+    this.name = "ForgeStorageError";
+  }
+};
+var ForgePolicyViolationError = class extends MiosaError {
+  constructor(message, cause) {
+    super(message, cause.status, cause.code, cause.details, cause.requestId);
+    this.name = "ForgePolicyViolationError";
+  }
+};
+function translateError(error) {
+  if (!(error instanceof MiosaError)) throw error;
+  if (error.code === "FORGE_DISABLED") {
+    throw new ForgeUnavailableError("Forge is not enabled for this organization", error);
+  }
+  if (error.code === "FORGE_STORAGE_UNAVAILABLE" || error.code === "FORGE_OPERATION_FAILED") {
+    throw new ForgeStorageError("Forge repository storage is unavailable", error);
+  }
+  if (error.code === "INVALID_PROJECT_ATTACHMENT") {
+    throw new ForgePolicyViolationError("Forge repository policy rejected the operation", error);
+  }
+  throw error;
+}
+function repositoryPath(id) {
+  return `/forge/repositories/${encodeURIComponent(id)}`;
+}
+function compact(value) {
+  return Object.fromEntries(
+    Object.entries(value).filter(([, item]) => item !== void 0)
+  );
+}
+function object(payload, label) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new ForgeContractError(`Forge returned invalid ${label}`, { payload });
+  }
+  return payload;
+}
+function string(value, field, payload) {
+  if (typeof value !== "string") {
+    throw new ForgeContractError(`Forge content is missing ${field}`, { field, payload });
+  }
+  return value;
+}
+function nullableString(value, field, payload) {
+  if (value !== null && typeof value !== "string") {
+    throw new ForgeContractError(`Forge content has invalid ${field}`, { field, payload });
+  }
+  return value;
+}
+function queryPath(path, params) {
+  const query3 = new URLSearchParams();
+  for (const [key, value] of Object.entries(params)) {
+    if (value !== void 0) query3.set(key, String(value));
+  }
+  const encoded = query3.toString();
+  return encoded ? `${path}?${encoded}` : path;
+}
+function parseNamedRef(payload) {
+  const value = object(payload, "repository ref");
+  return { name: string(value.name, "name", payload), oid: string(value.oid, "oid", payload) };
+}
+function parseRefs(payload) {
+  const value = object(payload, "repository refs");
+  if (!Array.isArray(value.branches) || !Array.isArray(value.tags)) {
+    throw new ForgeContractError("Forge repository refs have invalid collections", { payload });
+  }
+  const branches = value.branches.map((item) => {
+    const branch = object(item, "branch");
+    if (typeof branch.is_default !== "boolean") {
+      throw new ForgeContractError("Forge branch is missing is_default", { payload: item });
+    }
+    return { ...parseNamedRef(item), is_default: branch.is_default };
+  });
+  return {
+    default_branch: string(value.default_branch, "default_branch", payload),
+    head_oid: nullableString(value.head_oid, "head_oid", payload),
+    branches,
+    tags: value.tags.map(parseNamedRef)
+  };
+}
+function parseTree(payload) {
+  const value = object(payload, "repository tree");
+  if (!Array.isArray(value.entries) || typeof value.truncated !== "boolean") {
+    throw new ForgeContractError("Forge repository tree has invalid entries", { payload });
+  }
+  const entries = value.entries.map((item) => {
+    const entry = object(item, "tree entry");
+    if (entry.type !== "blob" && entry.type !== "tree") {
+      throw new ForgeContractError("Forge tree entry has invalid type", { payload: item });
+    }
+    if (entry.size !== null && (typeof entry.size !== "number" || !Number.isSafeInteger(entry.size) || entry.size < 0)) {
+      throw new ForgeContractError("Forge tree entry has invalid size", { payload: item });
+    }
+    return {
+      name: string(entry.name, "name", item),
+      path: string(entry.path, "path", item),
+      type: entry.type,
+      oid: string(entry.oid, "oid", item),
+      size: entry.size
+    };
+  });
+  return {
+    ref: string(value.ref, "ref", payload),
+    commit_oid: string(value.commit_oid, "commit_oid", payload),
+    path: string(value.path, "path", payload),
+    entries,
+    truncated: value.truncated
+  };
+}
+function parseBlob(payload) {
+  const value = object(payload, "repository blob");
+  if (value.encoding !== "utf-8" && value.encoding !== "base64") {
+    throw new ForgeContractError("Forge blob has invalid encoding", { payload });
+  }
+  if (typeof value.size !== "number" || !Number.isSafeInteger(value.size) || value.size < 0) {
+    throw new ForgeContractError("Forge blob has invalid size", { payload });
+  }
+  return {
+    ref: string(value.ref, "ref", payload),
+    commit_oid: string(value.commit_oid, "commit_oid", payload),
+    path: string(value.path, "path", payload),
+    oid: string(value.oid, "oid", payload),
+    size: value.size,
+    encoding: value.encoding,
+    content: string(value.content, "content", payload)
+  };
+}
+function parseHistory(payload) {
+  const value = object(payload, "commit history");
+  const page = object(value.page, "commit page");
+  if (!Array.isArray(value.commits) || typeof page.has_more !== "boolean") {
+    throw new ForgeContractError("Forge commit history has invalid pagination", { payload });
+  }
+  const commits = value.commits.map((item) => {
+    const commit = object(item, "commit");
+    if (!Array.isArray(commit.parents) || !commit.parents.every((parent) => typeof parent === "string")) {
+      throw new ForgeContractError("Forge commit has invalid parents", { payload: item });
+    }
+    return {
+      oid: string(commit.oid, "oid", item),
+      short_oid: string(commit.short_oid, "short_oid", item),
+      subject: string(commit.subject, "subject", item),
+      author_name: string(commit.author_name, "author_name", item),
+      author_email: string(commit.author_email, "author_email", item),
+      authored_at: string(commit.authored_at, "authored_at", item),
+      committer_name: string(commit.committer_name, "committer_name", item),
+      committed_at: string(commit.committed_at, "committed_at", item),
+      parents: commit.parents
+    };
+  });
+  return {
+    ref: string(value.ref, "ref", payload),
+    path: string(value.path, "path", payload),
+    commits,
+    page: { has_more: page.has_more, next_cursor: nullableString(page.next_cursor, "next_cursor", page) }
+  };
+}
+function parseFileReceipt(payload, replayed) {
+  const value = object(payload, "file operation receipt");
+  const commit = object(value.commit, "file operation commit");
+  const policy = object(value.policy, "file operation policy");
+  const stringFields = ["operation_id", "repository_id", "branch", "path", "previous_head", "new_head"];
+  if (stringFields.some((field) => typeof value[field] !== "string") || !["create", "update", "delete"].includes(String(value.action)) || policy.decision !== "allowed" || !Array.isArray(policy.receipt_ids) || !policy.receipt_ids.every((id) => typeof id === "string") || typeof commit.oid !== "string" || typeof commit.committed_at !== "string") {
+    throw new ForgeContractError("Forge returned invalid file operation receipt", { payload });
+  }
+  return { ...value, replayed };
+}
+function parseRepository(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new ForgeContractError("Forge returned an invalid repository", {
+      payload
+    });
+  }
+  const value = payload;
+  const requiredStrings = [
+    "id",
+    "name",
+    "slug",
+    "default_branch",
+    "visibility",
+    "state",
+    "created_at",
+    "updated_at"
+  ];
+  for (const field of requiredStrings) {
+    if (typeof value[field] !== "string" || value[field].length === 0) {
+      throw new ForgeContractError(`Forge repository is missing ${field}`, {
+        field,
+        payload
+      });
+    }
+  }
+  if (!REPOSITORY_VISIBILITIES.has(value.visibility)) {
+    throw new ForgeContractError("Forge repository has an invalid visibility", {
+      payload
+    });
+  }
+  if (!REPOSITORY_STATES.has(value.state)) {
+    throw new ForgeContractError("Forge repository has an invalid state", {
+      payload
+    });
+  }
+  if (typeof value.clone_ready !== "boolean" || value.clone_url !== null && typeof value.clone_url !== "string" || !Array.isArray(value.project_ids) || !value.project_ids.every((id) => typeof id === "string"))
+    throw new ForgeContractError("Forge repository has invalid clone or project metadata", { payload });
+  if (value.clone_ready !== (value.state === "active") || value.clone_ready && !value.clone_url || !value.clone_ready && value.clone_url !== null)
+    throw new ForgeContractError("Forge repository clone readiness is inconsistent", { payload });
+  return {
+    id: value.id,
+    name: value.name,
+    slug: value.slug,
+    default_branch: value.default_branch,
+    visibility: value.visibility,
+    state: value.state,
+    clone_ready: value.clone_ready,
+    clone_url: value.clone_url,
+    project_ids: value.project_ids,
+    created_at: value.created_at,
+    updated_at: value.updated_at
+  };
+}
+function parseCapabilities(payload) {
+  const value = object(payload, "capabilities");
+  const valid = value.api_version === "v1" && value.ownership === "organization" && value.detail_locator === "repository_id" && typeof value.base_url === "string" && Array.isArray(value.lifecycle_states) && Array.isArray(value.visibility_values) && Array.isArray(value.clone_ready_states) && value.clone_ready_states.length === 1 && value.clone_ready_states[0] === "active" && value.features && typeof value.features === "object";
+  if (!valid) throw new ForgeContractError("Forge returned invalid capabilities", { payload });
+  return value;
+}
+var ForgeRepositories = class {
+  constructor(http) {
+    this.http = http;
+  }
+  http;
+  async create(params) {
+    try {
+      const payload = await this.http.request("/forge/repositories", {
+        method: "POST",
+        headers: { "Idempotency-Key": params.idempotencyKey ?? crypto.randomUUID() },
+        body: compact({
+          name: params.name,
+          slug: params.slug,
+          default_branch: params.defaultBranch,
+          visibility: params.visibility,
+          project_ids: params.projectIds
+        })
+      });
+      return parseRepository(unwrapData2(payload));
+    } catch (error) {
+      translateError(error);
+    }
+  }
+  async list() {
+    const payload = await this.http.get("/forge/repositories");
+    if (!payload || typeof payload !== "object" || Array.isArray(payload) || !Array.isArray(payload.data)) {
+      throw new ForgeContractError("Forge returned an invalid repository list", {
+        payload
+      });
+    }
+    return payload.data.map(
+      parseRepository
+    );
+  }
+  async get(id) {
+    return parseRepository(unwrapData2(await this.http.get(repositoryPath(id))));
+  }
+  async refs(id) {
+    return parseRefs(unwrapData2(await this.http.get(`${repositoryPath(id)}/refs`)));
+  }
+  async tree(id, location = {}) {
+    const path = queryPath(`${repositoryPath(id)}/tree`, { ref: location.ref, path: location.path });
+    return parseTree(unwrapData2(await this.http.get(path)));
+  }
+  async blob(id, location) {
+    const path = queryPath(`${repositoryPath(id)}/blob`, { ref: location.ref, path: location.path });
+    return parseBlob(unwrapData2(await this.http.get(path)));
+  }
+  async readme(id, location = {}) {
+    const path = queryPath(`${repositoryPath(id)}/readme`, { ref: location.ref, path: location.path });
+    return parseBlob(unwrapData2(await this.http.get(path)));
+  }
+  async commits(id, query3 = {}) {
+    const path = queryPath(`${repositoryPath(id)}/commits`, {
+      ref: query3.ref,
+      path: query3.path,
+      limit: query3.limit,
+      cursor: query3.cursor
+    });
+    return parseHistory(unwrapData2(await this.http.get(path)));
+  }
+  async putFile(id, path, params) {
+    return this.authorFile(id, path, "PUT", params);
+  }
+  async deleteFile(id, path, params) {
+    return this.authorFile(id, path, "DELETE", params);
+  }
+  async authorFile(id, path, method, params) {
+    const response = await this.http.request(`${repositoryPath(id)}/files/${path.split("/").map(encodeURIComponent).join("/")}`, {
+      method,
+      rawResponse: true,
+      headers: { "Idempotency-Key": params.idempotencyKey ?? crypto.randomUUID() },
+      body: compact({ branch: params.branch, expected_head: params.expectedHead, message: params.message, content: params.content })
+    });
+    let payload;
+    try {
+      payload = await response.json();
+    } catch {
+      throw new ForgeContractError("Forge returned invalid file operation JSON");
+    }
+    return parseFileReceipt(unwrapData2(payload), response.headers.get("idempotency-replayed") === "true");
+  }
+  async update(id, params) {
+    try {
+      const payload = await this.http.request(repositoryPath(id), { method: "PATCH", body: compact({
+        name: params.name,
+        slug: params.slug,
+        visibility: params.visibility,
+        project_ids: params.projectIds
+      }) });
+      return parseRepository(unwrapData2(payload));
+    } catch (error) {
+      translateError(error);
+    }
+  }
+  async delete(id, _options = {}) {
+    try {
+      const response = await this.http.request(repositoryPath(id), {
+        method: "DELETE",
+        rawResponse: true
+      });
+      const operationId = response.headers.get("x-forge-operation-id");
+      if (!operationId) throw new ForgeContractError("Forge delete omitted its operation receipt");
+      return { operation_id: operationId, replayed: response.headers.get("idempotency-replayed") === "true" };
+    } catch (error) {
+      translateError(error);
+    }
+  }
+};
+function unwrapData2(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload) || !("data" in payload))
+    throw new ForgeContractError("Forge returned an invalid success envelope", { payload });
+  return payload.data;
+}
+var Forge = class {
+  repositories;
+  constructor(http) {
+    this.repositories = new ForgeRepositories(http);
+    this.http = http;
+  }
+  http;
+  async capabilities() {
+    return parseCapabilities(unwrapData2(await this.http.get("/forge/capabilities")));
+  }
+};
 function unwrap38(payload) {
   if (payload && typeof payload === "object" && "data" in payload) {
     return payload.data;
@@ -9018,19 +9398,40 @@ var Sandbox = class _Sandbox {
     const stream = options.stream ?? true;
     if (stream) {
       const sseResult = await this.tryReadinessStream(timeout);
-      if (sseResult !== null) return sseResult;
+      if (sseResult !== null) {
+        if (sseResult) await this.adoptReadyState();
+        return sseResult;
+      }
     }
     const deadlineMs = Date.now() + timeout * 1e3;
     while (Date.now() < deadlineMs) {
       try {
         const data = await this.readiness();
-        if (data.ready === true || data.status === "ready") return true;
+        if (data.ready === true || data.status === "ready") {
+          await this.adoptReadyState();
+          return true;
+        }
       } catch {
       }
       await new Promise((resolve) => setTimeout(resolve, 10));
     }
     return false;
   }
+  /**
+   * Readiness answers from the server; `assertRunning` reads the local
+   * snapshot. Leaving that snapshot behind meant a caller could await
+   * `waitUntilReady()`, receive `true`, and have the very next call refused
+   * for being "provisioning" — the sandbox was running the whole time, only
+   * this object had not been told. Nothing here can fail the wait: readiness
+   * has already answered, so a refresh that does not land is not the caller's
+   * problem.
+   */
+  async adoptReadyState() {
+    try {
+      await this.refresh();
+    } catch {
+    }
+  }
   /**
    * Returns `true` / `false` for terminal SSE events, or `null` if the
    * stream endpoint is unavailable (404 or transport error) so callers
@@ -10342,6 +10743,7 @@ var Miosa = class {
   orgInvites;
   /** Organizations available to the user session, membership, invites, and switching. */
   organizations;
+  forge;
   /** Current tenant plan, limits, and live usage counters. */
   tenant;
   /** Datacenter regions, compute sizes, pricing, community templates. */
@@ -10489,6 +10891,7 @@ var Miosa = class {
     this.workspaceInvites = new WorkspaceInvites(this.http);
     this.orgInvites = new OrgInvites(this.http);
     this.organizations = new Organizations(this.http);
+    this.forge = new Forge(this.http);
     this.tenant = new Tenant(this.http);
     this.regions = new Regions(this.http);
     this.settings = new Settings(this.http);
@@ -11036,6 +11439,6 @@ var AppAuth = class {
   }
 };
 
-export { AGENT_BUILD_KIND_SPECS, Admin, AgentDefinitions, AgentRuntimeProfiles, Analytics, ApiKeys, AppAuth, AppDocuments, AuditLog, AuthError, Benchmarks, BuilderSessions, Channels, Checkpoints, Cloud, CommandCenter, Community, Completions, Computer, ComputerAudit, ComputerAutoStop, ComputerConnectors, ComputerEnv, ComputerInbox, ComputerLogs, ComputerNetwork, ComputerOsa, ComputerPorts, ComputerSecrets, ComputerTerminal, ComputerVolumes, Computers, Connectors, Credits, CronJobs, DEFAULT_AGENT_BUILD_OUTPUT_ROOT, DEFAULT_AGENT_BUILD_PACKET_VERSION, Dashboard, Databases, DeploymentConnectors, DeploymentDomains, DeploymentReleases, DeploymentRuntimeInstances, DeploymentVersions, Deployments, Desktop, Devices, DockerDeploy, EgressAudit, EgressHostNotAllowedError, EgressNetwork, EgressSecrets, Email, EmailCampaigns, EmailInbox, EmailTemplates, Embeddings, Exec, ExternalKeys, Files, FlatCustomDomains, Functions, HealthChecks, InstallationRequiredError, InsufficientCreditsError, Integrations, ManagedProviderBindingOnlyError, Mcp, Miosa, MiosaError, Models, NetworkError, NetworkPolicy, NotFoundError, OAuthFlow, OpenComputers, OrgInvites, OrganizationMembers, Organizations, ProjectAuth, ProjectIntegrations, ProjectNotLinkedError, ProviderDefaults, RateLimitError, Regions, RunGroups, Runs, RuntimeCapabilitiesResource, RuntimeEnv, SANDBOX_TEMPLATE, Sandbox, SandboxAudit, SandboxCommands, SandboxConnectors, SandboxEnv, SandboxEvents, SandboxFiles, SandboxNetwork, SandboxPreview, SandboxPreviews, SandboxSecrets, SandboxTags, SandboxTemplates, SandboxTerminal, Sandboxes, ScopeNotAllowedError, ScopedFs, Settings, SnapshotsStandalone, Storage, SubjectNotAllowedError, Templates, Tenant, TimeoutError, TokenRefreshFailedError, Usage, UserAuthorizationRequiredError, ValidationError, Volumes, Webhooks, WorkspaceInvites, WorkspaceMembers, createAgentBuildExecutionPacket, createAgentBuildExpectedOutputs, createAgentBuildPrompt, createBuildRunParams, getAgentBuildKindSpec, resolveAgentBuildKind, verifySignature };
+export { AGENT_BUILD_KIND_SPECS, Admin, AgentDefinitions, AgentRuntimeProfiles, Analytics, ApiKeys, AppAuth, AppDocuments, AuditLog, AuthError, Benchmarks, BuilderSessions, Channels, Checkpoints, Cloud, CommandCenter, Community, Completions, Computer, ComputerAudit, ComputerAutoStop, ComputerConnectors, ComputerEnv, ComputerInbox, ComputerLogs, ComputerNetwork, ComputerOsa, ComputerPorts, ComputerSecrets, ComputerTerminal, ComputerVolumes, Computers, Connectors, Credits, CronJobs, DEFAULT_AGENT_BUILD_OUTPUT_ROOT, DEFAULT_AGENT_BUILD_PACKET_VERSION, Dashboard, Databases, DeploymentConnectors, DeploymentDomains, DeploymentReleases, DeploymentRuntimeInstances, DeploymentVersions, Deployments, Desktop, Devices, DockerDeploy, EgressAudit, EgressHostNotAllowedError, EgressNetwork, EgressSecrets, Email, EmailCampaigns, EmailInbox, EmailTemplates, Embeddings, Exec, ExternalKeys, Files, FlatCustomDomains, Forge, ForgeContractError, ForgePolicyViolationError, ForgeRepositories, ForgeStorageError, ForgeUnavailableError, Functions, HealthChecks, InstallationRequiredError, InsufficientCreditsError, Integrations, ManagedProviderBindingOnlyError, Mcp, Miosa, MiosaError, Models, NetworkError, NetworkPolicy, NotFoundError, OAuthFlow, OpenComputers, OrgInvites, OrganizationMembers, Organizations, ProjectAuth, ProjectIntegrations, ProjectNotLinkedError, ProviderDefaults, RateLimitError, Regions, RunGroups, Runs, RuntimeCapabilitiesResource, RuntimeEnv, SANDBOX_TEMPLATE, Sandbox, SandboxAudit, SandboxCommands, SandboxConnectors, SandboxEnv, SandboxEvents, SandboxFiles, SandboxNetwork, SandboxPreview, SandboxPreviews, SandboxSecrets, SandboxTags, SandboxTemplates, SandboxTerminal, Sandboxes, ScopeNotAllowedError, ScopedFs, Settings, SnapshotsStandalone, Storage, SubjectNotAllowedError, Templates, Tenant, TimeoutError, TokenRefreshFailedError, Usage, UserAuthorizationRequiredError, ValidationError, Volumes, Webhooks, WorkspaceInvites, WorkspaceMembers, createAgentBuildExecutionPacket, createAgentBuildExpectedOutputs, createAgentBuildPrompt, createBuildRunParams, getAgentBuildKindSpec, resolveAgentBuildKind, verifySignature };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map