@pickaxe/harnesslayer 0.1.0

package/dist/index.js

@@ -0,0 +1,1501 @@
+// src/errors.ts
+var HarnesslayerError = class extends Error {
+  name = "HarnesslayerError";
+};
+var HarnesslayerHTTPError = class extends HarnesslayerError {
+  name = "HarnesslayerHTTPError";
+};
+var HarnesslayerResponseError = class extends HarnesslayerError {
+  name = "HarnesslayerResponseError";
+};
+var HarnesslayerAPIError = class extends HarnesslayerError {
+  name = "HarnesslayerAPIError";
+};
+var DriftstoneError = class extends Error {
+  name = "DriftstoneError";
+};
+var DriftstoneHTTPError = class extends DriftstoneError {
+  name = "DriftstoneHTTPError";
+};
+var DriftstoneResponseError = class extends DriftstoneError {
+  name = "DriftstoneResponseError";
+};
+var DriftstoneAPIError = class extends DriftstoneError {
+  name = "DriftstoneAPIError";
+};
+
+// src/internal/constants.ts
+var DEFAULT_API_BASE_URL = "https://pickaxeproject--harnesslayer-api-v2-api.modal.run";
+var DEFAULT_DRIFTSTONE_API_BASE_URL = "https://api.driftstone.ai";
+
+// src/internal/driftstone.ts
+import { readFile } from "fs/promises";
+import path from "path";
+var DriftstoneClient = class {
+  repos;
+  baseUrl;
+  headers;
+  timeoutMs;
+  fetchImpl;
+  constructor(options) {
+    const apiKey = options.apiKey.trim();
+    if (!apiKey) throw new DriftstoneError("apiKey must be provided");
+    if (!apiKey.startsWith("dk-")) throw new DriftstoneError("Invalid Driftstone API key");
+    this.baseUrl = `${(options.baseUrl ?? DEFAULT_DRIFTSTONE_API_BASE_URL).replace(/\/+$/, "")}/${options.version}`;
+    this.timeoutMs = options.timeoutMs;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.headers = {
+      Authorization: `Bearer ${apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": "Harnesslayer-typescript/0.1.0"
+    };
+    this.repos = new DriftstoneRepositories(this);
+  }
+  async request(method, requestPath, payload = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const url = new URL(requestPath.replace(/^\/+/, ""), `${this.baseUrl}/`);
+      const init = {
+        method,
+        headers: this.headers,
+        signal: controller.signal
+      };
+      if (method === "GET") {
+        for (const [key, value] of Object.entries(payload)) {
+          if (value != null) url.searchParams.set(key, String(value));
+        }
+      } else if (Object.keys(payload).length) {
+        init.body = JSON.stringify(payload);
+      }
+      const response = await this.fetchImpl(url, init);
+      const data = await this.parseResponse(response);
+      if (response.status >= 400) {
+        throw new DriftstoneAPIError(
+          `Driftstone API returned error status ${response.status}: ${JSON.stringify(data)}`
+        );
+      }
+      if (data.success === false) {
+        throw new DriftstoneAPIError(
+          `Driftstone API error: ${String(data.error ?? data.message ?? "Request failed")}`
+        );
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof DriftstoneAPIError || error instanceof DriftstoneResponseError) {
+        throw error;
+      }
+      throw new DriftstoneHTTPError(
+        `HTTP request failed: ${error instanceof Error ? error.message : String(error)}`
+      );
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async uploadFile(url, filePath) {
+    const trimmedUrl = url.trim();
+    if (!trimmedUrl) throw new DriftstoneError("url must be a non-empty string");
+    const response = await this.fetchImpl(trimmedUrl, {
+      method: "PUT",
+      headers: { "Content-Type": "application/octet-stream" },
+      body: await readFile(filePath)
+    });
+    if (response.status >= 400) {
+      throw new DriftstoneHTTPError(`File upload failed with status ${response.status}`);
+    }
+    return true;
+  }
+  async uploadFiles(upload, files, root) {
+    const uploadUrls = new Map(upload.uploadUrls.map((item) => [item.name, item.url]));
+    const rootPath = path.resolve(root);
+    for (const file of files) {
+      const url = uploadUrls.get(file.name);
+      if (!url) throw new DriftstoneError(`Missing upload URL for file '${file.name}'`);
+      const filePath = path.resolve(rootPath, file.name);
+      if (filePath !== rootPath && !filePath.startsWith(`${rootPath}${path.sep}`)) {
+        throw new DriftstoneError(`file path must stay within root: ${file.name}`);
+      }
+      await this.uploadFile(url, filePath);
+    }
+    return true;
+  }
+  async parseResponse(response) {
+    let decoded;
+    try {
+      decoded = await response.json();
+    } catch {
+      throw new DriftstoneResponseError(
+        `Driftstone API returned non-JSON response (status=${response.status})`
+      );
+    }
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+      throw new DriftstoneResponseError("Driftstone API returned an unexpected response payload");
+    }
+    return decoded;
+  }
+};
+var DriftstoneRepositories = class {
+  constructor(client) {
+    this.client = client;
+  }
+  client;
+  async create(name) {
+    const response = await this.client.request("POST", "/repos", { name: requireDriftstoneString(name, "name") });
+    return repositoryFromApi(response.data);
+  }
+  async get(repo) {
+    const response = await this.client.request("GET", `/repos/${encodeRepo(repo)}`);
+    return repositoryFromApi(response.data);
+  }
+  async createBranch(repo, name, options) {
+    const payload = {
+      name: requireRouteSegment(name, "name"),
+      storageDir: requireRouteSegment(options.storageDir, "storageDir"),
+      archive: options.archive ?? true
+    };
+    if (options.message != null) payload.message = requireDriftstoneString(options.message, "message");
+    if (options.transforms != null) payload.transforms = options.transforms;
+    const response = await this.client.request("POST", `/repos/${encodeRepo(repo)}/branches`, payload);
+    return branchFromApi(response.data);
+  }
+  async createUpload(repo, options) {
+    const response = await this.client.request("POST", `/repos/${encodeRepo(repo)}/uploads`, {
+      branch: requireRouteSegment(options.branch ?? "main", "branch"),
+      storageDir: requireRouteSegment(options.storageDir, "storageDir"),
+      files: options.files
+    });
+    return uploadFromApi(response.data);
+  }
+  async completeUpload(repo, uploadId) {
+    await this.client.request(
+      "POST",
+      `/repos/${encodeRepo(repo)}/uploads/${requireRouteSegment(uploadId, "uploadId")}/complete`
+    );
+    return true;
+  }
+  async copyDirectory(repo, options) {
+    const response = await this.client.request("POST", `/repos/${encodeRepo(repo)}/copies`, {
+      sourceDir: requireRouteSegment(options.sourceDir, "sourceDir"),
+      destDir: requireRouteSegment(options.destDir, "destDir"),
+      sourceBranch: requireRouteSegment(options.sourceBranch ?? "main", "sourceBranch"),
+      destBranch: requireRouteSegment(options.destBranch ?? "main", "destBranch"),
+      transforms: options.transforms ?? {},
+      archive: options.archive ?? true
+    });
+    return copyFromApi(response.data);
+  }
+  async getCopyStatus(repo, runId) {
+    const response = await this.client.request(
+      "GET",
+      `/repos/${encodeRepo(repo)}/copies/${requireRouteSegment(runId, "runId")}`
+    );
+    return copyStatusFromApi(response.data);
+  }
+};
+function requireDriftstoneString(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new DriftstoneError(`${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function requireRouteSegment(value, name) {
+  const normalized = requireDriftstoneString(value, name);
+  if (normalized.includes("/") || normalized.includes("\\")) {
+    throw new DriftstoneError(`${name} cannot contain / or \\`);
+  }
+  return normalized;
+}
+function encodeRepo(repo) {
+  return encodeURIComponent(requireDriftstoneString(repo, "repo").replace(/^\/+|\/+$/g, ""));
+}
+function repositoryFromApi(payload) {
+  return {
+    id: String(payload.id),
+    orgId: String(payload.orgId),
+    name: String(payload.name),
+    slug: String(payload.slug),
+    branch: String(payload.branch)
+  };
+}
+function branchFromApi(payload) {
+  return {
+    id: String(payload.id),
+    repoId: String(payload.repoId),
+    name: String(payload.name),
+    storagePath: payload.storagePath ?? null,
+    runId: payload.runId ?? null,
+    status: payload.status ?? null
+  };
+}
+function copyFromApi(payload) {
+  return {
+    repoId: String(payload.repoId),
+    runId: String(payload.runId),
+    status: String(payload.status),
+    sourceDir: payload.sourceDir ?? null,
+    destDir: payload.destDir ?? null
+  };
+}
+function copyStatusFromApi(payload) {
+  return {
+    repoId: String(payload.repoId),
+    runId: String(payload.runId),
+    status: String(payload.status),
+    result: payload.result && typeof payload.result === "object" && !Array.isArray(payload.result) ? payload.result : null
+  };
+}
+function uploadFromApi(payload) {
+  const urls = Array.isArray(payload.uploadUrls) ? payload.uploadUrls : [];
+  return {
+    repoId: String(payload.repoId),
+    uploadId: String(payload.uploadId),
+    uploadUrls: urls.filter((item) => Boolean(item) && typeof item === "object").map((item) => ({ name: String(item.name), url: String(item.url) }))
+  };
+}
+
+// src/internal/transport.ts
+var Transport = class {
+  headers;
+  timeoutMs;
+  baseUrl;
+  fetchImpl;
+  constructor(options) {
+    this.baseUrl = options.baseUrl.replace(/\/+$/, "");
+    this.timeoutMs = options.timeoutMs;
+    this.fetchImpl = options.fetch ?? fetch;
+    this.headers = {
+      Authorization: `Bearer ${options.apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": options.userAgent
+    };
+  }
+  async request(method, path4, payload = {}) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const url = new URL(path4.replace(/^\/+/, ""), `${this.baseUrl}/`);
+      const init = {
+        method,
+        headers: this.headers,
+        signal: controller.signal
+      };
+      if (method === "GET") {
+        for (const [key, value] of Object.entries(payload)) {
+          if (value != null) url.searchParams.set(key, String(value));
+        }
+      } else {
+        init.body = JSON.stringify(payload);
+      }
+      const response = await this.fetchImpl(url, init);
+      const data = await this.parseResponse(response);
+      if (response.status >= 400) {
+        throw new HarnesslayerAPIError(
+          `Harnesslayer API returned error status ${response.status}: ${JSON.stringify(data)}`
+        );
+      }
+      if (data.success === false) {
+        const message = String(data.error ?? data.message ?? "Request failed");
+        throw new HarnesslayerAPIError(`Harnesslayer API error: ${message}`);
+      }
+      return data;
+    } catch (error) {
+      if (error instanceof HarnesslayerAPIError || error instanceof HarnesslayerResponseError) {
+        throw error;
+      }
+      const message = error instanceof Error ? error.message : String(error);
+      throw new HarnesslayerHTTPError(`HTTP request failed: ${message}`);
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  async parseResponse(response) {
+    let decoded;
+    try {
+      decoded = await response.json();
+    } catch (error) {
+      throw new HarnesslayerResponseError(
+        `Harnesslayer API returned non-JSON response (status=${response.status})`
+      );
+    }
+    if (!decoded || typeof decoded !== "object" || Array.isArray(decoded)) {
+      throw new HarnesslayerResponseError(
+        "Harnesslayer API returned an unexpected response payload"
+      );
+    }
+    return decoded;
+  }
+};
+
+// src/internal/config.ts
+import { createHash, randomUUID } from "crypto";
+import { readdir, readFile as readFile2, stat } from "fs/promises";
+import path2 from "path";
+
+// src/internal/utils.ts
+function safeParseJson(value) {
+  if (typeof value !== "string") return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+}
+function parseDate(value, field) {
+  if (value instanceof Date) return value;
+  if (typeof value === "string" || typeof value === "number") {
+    const date = new Date(value);
+    if (!Number.isNaN(date.getTime())) return date;
+  }
+  throw new TypeError(`Expected ${field} to be a date-compatible value`);
+}
+function parseOptionalDate(value, field) {
+  if (value == null) return null;
+  return parseDate(value, field);
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+// src/internal/config.ts
+var IGNORED_PARTS = /* @__PURE__ */ new Set(["__MACOSX"]);
+function newVersionId() {
+  return `ver-${randomUUID()}`;
+}
+function newStateId() {
+  return `state-${randomUUID()}`;
+}
+function validateCloneTransform(transform) {
+  if (transform == null) return {};
+  if (!transform || typeof transform !== "object" || Array.isArray(transform)) {
+    throw new HarnesslayerError("transform must be an object");
+  }
+  const normalized = {};
+  for (const [filePath, patch] of Object.entries(transform)) {
+    if (!filePath.trim()) {
+      throw new HarnesslayerError("transform keys must be non-empty strings");
+    }
+    const normalizedPath = filePath.trim().replace(/\\/g, "/");
+    if (normalizedPath.startsWith("/") || normalizedPath.split("/").includes("..")) {
+      throw new HarnesslayerError(`Invalid transform file path: ${filePath}`);
+    }
+    const lower = normalizedPath.toLowerCase();
+    if (lower.endsWith(".json")) {
+      if (!patch || typeof patch !== "object" || Array.isArray(patch)) {
+        throw new HarnesslayerError(`transform['${filePath}'] must be a JSON object patch`);
+      }
+    } else if (lower.endsWith(".md")) {
+      if (typeof patch !== "string") {
+        throw new HarnesslayerError(`transform['${filePath}'] must be Markdown string content`);
+      }
+    } else {
+      throw new HarnesslayerError(`transform target must be a .json or .md file: ${filePath}`);
+    }
+    normalized[normalizedPath] = patch;
+  }
+  return normalized;
+}
+async function validateConfigPath(configPath) {
+  const root = path2.resolve(configPath);
+  const rootStat = await stat(root).catch(() => null);
+  if (!rootStat) throw new HarnesslayerError(`Config path does not exist: ${root}`);
+  if (!rootStat.isDirectory()) throw new HarnesslayerError(`Config path must be a directory: ${root}`);
+  const basename = path2.basename(configPath);
+  if (basename.endsWith(".claude")) {
+    await validateClaudeConfigPath(root);
+    return { type: "claude", path: root };
+  }
+  if (basename.endsWith(".openclaw")) {
+    await validateOpenClawConfigPath(root);
+    return { type: "openclaw", path: root };
+  }
+  throw new HarnesslayerError(`Config path must end with .claude or .openclaw: ${configPath}`);
+}
+async function createUploadFilesPayload(root) {
+  const files = [];
+  const rootPath = path2.resolve(root);
+  async function walk(directory) {
+    const entries = await readdir(directory, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      if (IGNORED_PARTS.has(entry.name)) continue;
+      const absolute = path2.join(directory, entry.name);
+      const relative = path2.relative(rootPath, absolute).split(path2.sep).join("/");
+      if (relative.split("/").some((part) => IGNORED_PARTS.has(part))) continue;
+      if (entry.isDirectory()) {
+        await walk(absolute);
+      } else if (entry.isFile()) {
+        const bytes = await readFile2(absolute);
+        files.push({
+          name: relative,
+          hash: createHash("sha256").update(bytes).digest("hex")
+        });
+      }
+    }
+  }
+  await walk(rootPath);
+  if (!files.length) {
+    throw new HarnesslayerError(`Config path contains no files to upload: ${rootPath}`);
+  }
+  return files;
+}
+async function validateClaudeConfigPath(root) {
+  await requireFile(path2.join(root, "agent.json"), `Invalid Agent config path: missing agent.json in '${root}'`);
+  await requireFile(
+    path2.join(root, "environment.json"),
+    `Invalid Agent config path: missing environment.json in '${root}'`
+  );
+  const agentJson = safeParseJson(await readFile2(path2.join(root, "agent.json"), "utf8"));
+  if (!agentJson || typeof agentJson !== "object" || Array.isArray(agentJson)) {
+    throw new HarnesslayerError("agent.json is not a valid JSON object");
+  }
+  const skills = agentJson.skills;
+  if (Array.isArray(skills)) {
+    for (const skill of skills) {
+      if (!skill || typeof skill !== "object" || !("type" in skill)) {
+        throw new HarnesslayerError("Each skill in agent.json must be an object with a 'name' field");
+      }
+      if (skill.type !== "anthropic") {
+        throw new HarnesslayerError(
+          "Only skills of type 'anthropic' are supported in agent.json, if you want custom skills you must add them as a folder under 'skills' directory"
+        );
+      }
+    }
+  }
+  const entries = await readdir(root, { withFileTypes: true });
+  for (const entry of entries) {
+    if (IGNORED_PARTS.has(entry.name)) continue;
+    if (entry.isDirectory() && entry.name !== "skills") {
+      throw new HarnesslayerError(`Invalid Agent config path: unexpected subdirectory '${entry.name}' in '${root}'`);
+    }
+    if (entry.isFile() && !["agent.json", "environment.json"].includes(entry.name)) {
+      throw new HarnesslayerError(`Invalid Agent config path: unexpected file '${entry.name}' in '${root}'`);
+    }
+  }
+  const skillsDir = path2.join(root, "skills");
+  const skillsStat = await stat(skillsDir).catch(() => null);
+  if (!skillsStat?.isDirectory()) return;
+  const skillEntries = await readdir(skillsDir, { withFileTypes: true });
+  for (const skillEntry of skillEntries) {
+    if (IGNORED_PARTS.has(skillEntry.name)) continue;
+    if (!skillEntry.isDirectory()) {
+      throw new HarnesslayerError(`Invalid Agent config path: skill '${skillEntry.name}' is not a directory in '${root}'`);
+    }
+    await requireFile(
+      path2.join(skillsDir, skillEntry.name, "SKILL.md"),
+      `Invalid Agent config path: missing SKILL.md in skill '${skillEntry.name}' in '${root}'`
+    );
+  }
+}
+async function validateOpenClawConfigPath(root) {
+  await requireFile(
+    path2.join(root, "openclaw.json"),
+    `Invalid OpenClaw config path: missing openclaw.json in '${root}'`
+  );
+}
+async function requireFile(filePath, message) {
+  const fileStat = await stat(filePath).catch(() => null);
+  if (!fileStat?.isFile()) throw new HarnesslayerError(message);
+}
+
+// src/models.ts
+function accessGroupFromApi(payload) {
+  return {
+    id: String(payload.id),
+    appId: String(payload.appId),
+    name: String(payload.name),
+    limit: Number(payload.limit),
+    limitReset: payload.limitReset,
+    limitMessage: String(payload.limitMessage),
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt")
+  };
+}
+function appFromApi(payload, resources) {
+  return {
+    id: String(payload.id),
+    orgId: String(payload.orgId),
+    type: payload.type,
+    name: String(payload.name),
+    slug: String(payload.slug),
+    vaultId: payload.vaultId ?? null,
+    defaultAccessGroupId: payload.defaultAccessGroupId ?? null,
+    headVersionId: payload.headVersionId ?? null,
+    metadata: payload.metadata ?? null,
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt"),
+    ...resources,
+    access_group: resources.accessGroup
+  };
+}
+function channelFromApi(payload, run) {
+  const channelId = String(payload.id);
+  return {
+    id: channelId,
+    appId: String(payload.appId),
+    type: payload.type,
+    slug: String(payload.slug),
+    name: String(payload.name),
+    webhook: payload.webhook ?? null,
+    data: payload.data ?? null,
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt"),
+    run: (options) => run(channelId, options)
+  };
+}
+function organizationFromApi(payload) {
+  return {
+    id: String(payload.id),
+    name: String(payload.name),
+    slug: String(payload.slug),
+    createdBy: String(payload.createdBy),
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt")
+  };
+}
+function profileFromApi(payload, state) {
+  return {
+    id: String(payload.id),
+    appId: String(payload.appId),
+    identifier: String(payload.identifier),
+    currentSpending: Number(payload.currentSpending),
+    totalSpending: Number(payload.totalSpending),
+    metadata: payload.metadata ?? null,
+    headStateId: payload.headStateId ?? null,
+    initialChannelId: payload.initialChannelId ?? null,
+    accessGroupId: payload.accessGroupId ?? null,
+    lastResetAt: parseOptionalDate(payload.lastResetAt, "lastResetAt"),
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt"),
+    state
+  };
+}
+function sessionFromApi(payload) {
+  return {
+    id: String(payload.id),
+    appId: String(payload.appId),
+    type: payload.type,
+    userIds: Array.isArray(payload.userIds) ? payload.userIds.map(String) : [],
+    profileIds: Array.isArray(payload.profileIds) ? payload.profileIds.map(String) : [],
+    metadata: payload.metadata ?? null,
+    externalId: payload.externalId ?? null,
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt")
+  };
+}
+function instanceFromApi(payload) {
+  return {
+    id: String(payload.id),
+    appId: String(payload.appId),
+    versionId: String(payload.versionId),
+    channelId: String(payload.channelId),
+    sessionId: String(payload.sessionId),
+    profileId: String(payload.profileId),
+    accessGroupId: String(payload.accessGroupId),
+    stateId: payload.stateId ?? null,
+    identifier: String(payload.identifier),
+    timeout: Number(payload.timeout),
+    totalCost: Number(payload.totalCost),
+    costBreakdown: payload.costBreakdown ?? {},
+    tokenBreakdown: payload.tokenBreakdown ?? {},
+    metadata: payload.metadata ?? null,
+    status: payload.status,
+    error: payload.error ?? null,
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt")
+  };
+}
+function conflictFromApi(payload) {
+  return {
+    id: String(payload.id),
+    appId: String(payload.appId),
+    syncId: String(payload.syncId),
+    profileId: String(payload.profileId),
+    versionId: String(payload.versionId),
+    stateId: String(payload.stateId),
+    stateBranch: String(payload.stateBranch),
+    reason: payload.reason,
+    error: payload.error ?? null,
+    createdAt: parseDate(payload.createdAt, "createdAt"),
+    updatedAt: parseDate(payload.updatedAt, "updatedAt")
+  };
+}
+
+// src/internal/validation.ts
+function requireNonEmptyString(value, name) {
+  if (typeof value !== "string" || !value.trim()) {
+    throw new HarnesslayerError(`${name} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function validateSlug(slug) {
+  const trimmedSlug = requireNonEmptyString(slug, "slug");
+  if (![...trimmedSlug].every((char) => /[A-Za-z0-9_-]/.test(char))) {
+    throw new HarnesslayerError(
+      "slug must be URL-safe (only contain letters, numbers, hyphens, and underscores)"
+    );
+  }
+  if (/^[-_]|[-_]$/.test(trimmedSlug)) {
+    throw new HarnesslayerError("slug cannot start or end with a hyphen or underscore");
+  }
+  return trimmedSlug;
+}
+function validatePositiveInteger(value, name) {
+  if (!Number.isInteger(value) || value < 1) {
+    throw new HarnesslayerError(`${name} must be a positive integer`);
+  }
+  return value;
+}
+function ensureObject(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new HarnesslayerError(`${name} must be an object`);
+  }
+  return value;
+}
+function ensureStringMap(value, name) {
+  const object = ensureObject(value, name);
+  for (const [key, item] of Object.entries(object)) {
+    if (typeof key !== "string" || typeof item !== "string") {
+      throw new HarnesslayerError(`${name} must be an object of string keys and values`);
+    }
+  }
+  return object;
+}
+
+// src/resources/base.ts
+var ResourceBase = class {
+  client;
+  driftstone;
+  constructor(client) {
+    this.client = client;
+    this.driftstone = client.driftstone;
+  }
+};
+var AppBase = class extends ResourceBase {
+  appId;
+  constructor(client, appId) {
+    super(client);
+    this.appId = appId;
+  }
+};
+var ProfileBase = class extends AppBase {
+  profileId;
+  constructor(client, appId, profileId) {
+    super(client, appId);
+    this.profileId = profileId;
+  }
+};
+
+// src/resources/access-group.ts
+var HarnesslayerAccessGroup = class extends AppBase {
+  async create(name, limit, options = {}) {
+    const limitReset = options.limitReset;
+    if (!["daily", "monthly", "yearly"].includes(limitReset)) {
+      throw new HarnesslayerError("limitReset must be one of 'daily', 'monthly', or 'yearly'");
+    }
+    if (options.limitMessage != null && typeof options.limitMessage !== "string") {
+      throw new HarnesslayerError("limitMessage must be a string");
+    }
+    const payload = {
+      appId: this.appId,
+      name: requireNonEmptyString(name, "name"),
+      limit: validatePositiveInteger(limit, "limit"),
+      limitReset
+    };
+    if (options.limitMessage != null) payload.limitMessage = options.limitMessage;
+    const response = await this.client.request("POST", "/access_group/create", payload);
+    return accessGroupFromApi(response.data);
+  }
+  async retrieve(accessGroupId) {
+    try {
+      const id = requireNonEmptyString(accessGroupId, "accessGroupId");
+      const response = await this.client.request("GET", `/access_group/${id}`);
+      return accessGroupFromApi(response.data);
+    } catch (error) {
+      if (error instanceof HarnesslayerAPIError || error instanceof HarnesslayerHTTPError || error instanceof HarnesslayerResponseError) {
+        throw error;
+      }
+      if (error instanceof HarnesslayerError) return null;
+      throw error;
+    }
+  }
+  async update(accessGroupId, options) {
+    const id = requireNonEmptyString(accessGroupId, "accessGroupId");
+    const payload = {};
+    if (options.name != null) payload.name = requireNonEmptyString(options.name, "name");
+    if (options.limit != null) payload.limit = validatePositiveInteger(options.limit, "limit");
+    if (options.limitReset != null) {
+      if (!["daily", "monthly", "yearly"].includes(options.limitReset)) {
+        throw new HarnesslayerError("limitReset must be one of 'daily', 'monthly', or 'yearly'");
+      }
+      payload.limitReset = options.limitReset;
+    }
+    if (options.limitMessage != null) {
+      if (typeof options.limitMessage !== "string") throw new HarnesslayerError("limitMessage must be a string");
+      payload.limitMessage = options.limitMessage;
+    }
+    if (!Object.keys(payload).length) throw new HarnesslayerError("At least one field must be provided to update");
+    const response = await this.client.request("PATCH", `/access_group/${id}`, payload);
+    return accessGroupFromApi(response.data);
+  }
+  async list(options = {}) {
+    const response = await this.client.request("GET", "/access_group/list", {
+      appId: this.appId,
+      page: validatePositiveInteger(options.page ?? 1, "page"),
+      pageSize: validatePositiveInteger(options.pageSize ?? 10, "pageSize")
+    });
+    if (!Array.isArray(response.data)) {
+      throw new HarnesslayerError("Expected 'data' to be a list in access group list response");
+    }
+    return response.data.map((item) => accessGroupFromApi(item));
+  }
+  async delete(accessGroupId) {
+    const id = requireNonEmptyString(accessGroupId, "accessGroupId");
+    await this.client.request("DELETE", `/access_group/${id}`);
+    return true;
+  }
+};
+
+// src/resources/channel.ts
+var HarnesslayerChannel = class extends AppBase {
+  async init(slug, options) {
+    const payload = {
+      appId: this.appId,
+      type: options.type,
+      slug: validateSlug(slug),
+      returnIfExist: true
+    };
+    if (!["api", "imessage"].includes(options.type)) {
+      throw new HarnesslayerError("type must be either 'api' or 'imessage'");
+    }
+    if (options.name != null) payload.name = requireNonEmptyString(options.name, "name");
+    if (options.type === "api") {
+      if (options.webhook != null) {
+        this.validateWebhook(options.webhook);
+        payload.webhook = options.webhook;
+      }
+    } else {
+      this.validateIMessageData(options.data);
+      payload.data = options.data;
+    }
+    const response = await this.client.request("POST", "/channel/create", payload);
+    return channelFromApi(
+      response.data,
+      (channelId, runOptions) => this.run(channelId, runOptions)
+    );
+  }
+  async *run(channelId, options) {
+    const id = requireNonEmptyString(channelId, "channelId");
+    const userId = requireNonEmptyString(options.userId, "userId");
+    const input = options.input ?? "";
+    if (typeof input !== "string") throw new HarnesslayerError("input must be a string");
+    if (options.images != null && !Array.isArray(options.images)) throw new HarnesslayerError("images must be a list");
+    const channel = await this.client.request("GET", `/channel/${id}`);
+    const data = channel.data;
+    if (data.type === "imessage") {
+      throw new HarnesslayerError("You must text the iMessage number directly to trigger the channel");
+    }
+    const payload = {
+      appId: this.appId,
+      channelId: id,
+      sessionId: options.sessionId ?? null,
+      userId,
+      input
+    };
+    if (options.images?.length) payload.images = options.images;
+    const runResponse = await this.client.request("POST", "/response/run", payload);
+    const instanceId = String(runResponse.data.instanceId);
+    let nextIndex = 0;
+    let backoff = 150;
+    while (true) {
+      const poll = await this.client.request("GET", `/response/poll/${instanceId}`, {
+        after: nextIndex,
+        timeoutMs: 25e3
+      });
+      const pollData = poll.data;
+      const status = pollData.status ?? "running";
+      const events = Array.isArray(pollData.events) ? pollData.events : [];
+      for (const event of events) {
+        const index = Number(event.index);
+        if (index < nextIndex) continue;
+        nextIndex = index + 1;
+        yield {
+          instanceId,
+          index,
+          data: safeParseJson(event.data) ?? { type: "unknown" },
+          done: status !== "running",
+          error: event.error ?? null
+        };
+      }
+      if (status !== "running") return;
+      if (events.length) {
+        backoff = 150;
+      } else {
+        await sleep(backoff);
+        backoff = Math.min(backoff * 1.5, 1500);
+      }
+    }
+  }
+  validateWebhook(webhook) {
+    if (!webhook || typeof webhook !== "object" || Array.isArray(webhook)) {
+      throw new HarnesslayerError("webhook must be an object with 'name', 'url', and optional 'headers'");
+    }
+    requireNonEmptyString(webhook.name, "webhook.name");
+    requireNonEmptyString(webhook.url, "webhook.url");
+    if (webhook.headers != null) ensureStringMap(webhook.headers, "webhook.headers");
+  }
+  validateIMessageData(data) {
+    if (!data || typeof data !== "object" || Array.isArray(data)) {
+      throw new HarnesslayerError("data must be an object with iMessage credentials");
+    }
+    for (const field of ["sendBlueAPIKey", "sendBlueSecretKey", "fromNumber"]) {
+      requireNonEmptyString(data[field], `data.${field}`);
+    }
+  }
+};
+
+// src/resources/conflict.ts
+var HarnesslayerConflict = class extends AppBase {
+  async retrieve(conflictId) {
+    try {
+      const response = await this.client.request("GET", `/conflict/${requireNonEmptyString(conflictId, "conflictId")}`);
+      return conflictFromApi(response.data);
+    } catch (error) {
+      if (error instanceof HarnesslayerAPIError || error instanceof HarnesslayerHTTPError || error instanceof HarnesslayerResponseError) {
+        throw error;
+      }
+      if (error instanceof HarnesslayerError) return null;
+      throw error;
+    }
+  }
+  async list(options = {}) {
+    const response = await this.client.request("GET", "/conflict/list", {
+      appId: this.appId,
+      page: validatePositiveInteger(options.page ?? 1, "page"),
+      pageSize: validatePositiveInteger(options.pageSize ?? 10, "pageSize")
+    });
+    if (!Array.isArray(response.data)) throw new HarnesslayerError("Expected 'data' to be a list in conflict list response");
+    return response.data.map((item) => conflictFromApi(item));
+  }
+};
+
+// src/resources/instance.ts
+var HarnesslayerInstance = class extends AppBase {
+  async retrieve(instanceId) {
+    try {
+      const response = await this.client.request("GET", `/instance/${requireNonEmptyString(instanceId, "instanceId")}`);
+      return instanceFromApi(response.data);
+    } catch (error) {
+      if (error instanceof HarnesslayerAPIError || error instanceof HarnesslayerHTTPError || error instanceof HarnesslayerResponseError) {
+        throw error;
+      }
+      if (error instanceof HarnesslayerError) return null;
+      throw error;
+    }
+  }
+  async list(options = {}) {
+    const response = await this.client.request("GET", "/instance/list", {
+      appId: this.appId,
+      page: validatePositiveInteger(options.page ?? 1, "page"),
+      pageSize: validatePositiveInteger(options.pageSize ?? 10, "pageSize")
+    });
+    if (!Array.isArray(response.data)) throw new HarnesslayerError("Expected 'data' to be a list in instance list response");
+    return response.data.map((item) => instanceFromApi(item));
+  }
+};
+
+// src/internal/zip.ts
+import { mkdir, writeFile } from "fs/promises";
+import path3 from "path";
+import { unzipSync } from "fflate";
+async function extractZip(bytes, outPath) {
+  const outDir = path3.resolve(outPath);
+  const entries = unzipSync(bytes);
+  for (const [entryName, data] of Object.entries(entries)) {
+    const target = path3.resolve(outDir, entryName);
+    if (target !== outDir && !target.startsWith(`${outDir}${path3.sep}`)) {
+      throw new HarnesslayerError(`Archive entry escapes output directory: ${entryName}`);
+    }
+    if (entryName.endsWith("/")) {
+      await mkdir(target, { recursive: true });
+      continue;
+    }
+    await mkdir(path3.dirname(target), { recursive: true });
+    await writeFile(target, data);
+  }
+}
+
+// src/resources/state.ts
+var HarnesslayerState = class extends ProfileBase {
+  async create(options) {
+    if (!options.stateId && !options.statePath) {
+      throw new HarnesslayerError("Either stateId or statePath must be provided");
+    }
+    const payload = { profileId: this.profileId };
+    if (options.stateId) {
+      if (!options.stateId.startsWith("state-")) throw new HarnesslayerError("stateId is invalid");
+      payload.stateId = options.stateId;
+    } else if (options.statePath) {
+      const stateId = newStateId();
+      const pathData = await validateConfigPath(options.statePath);
+      const files = await createUploadFilesPayload(pathData.path);
+      const repo = await this.driftstone.repos.get(this.appId);
+      const upload = await this.driftstone.repos.createUpload(repo.id, {
+        branch: this.profileId,
+        storageDir: stateId,
+        files
+      });
+      await this.driftstone.uploadFiles(upload, files, pathData.path);
+      await this.driftstone.repos.completeUpload(repo.id, upload.uploadId);
+      payload.stateId = stateId;
+    }
+    await this.client.request("POST", "/state/create", payload);
+    return true;
+  }
+  async download(outPath, stateId) {
+    const targetStateId = await this.resolveStateId(stateId);
+    const response = await this.client.request("POST", `/state/download/${targetStateId}`);
+    const url = response.data.url;
+    if (typeof url !== "string" || !url.trim()) throw new HarnesslayerResponseError("Missing download URL for state");
+    const archive = await fetch(url, { redirect: "follow" });
+    if (archive.status >= 400) throw new HarnesslayerAPIError("Failed to download state archive");
+    await extractZip(new Uint8Array(await archive.arrayBuffer()), outPath);
+    return true;
+  }
+  async clone(options = {}) {
+    try {
+      const transforms = validateCloneTransform(options.transform);
+      const newId = newStateId();
+      const targetStateId = await this.tryResolveStateId(options.stateId);
+      if (targetStateId) {
+        if (!targetStateId.startsWith("state-")) throw new HarnesslayerError("stateId is invalid");
+        const copyJob = await this.driftstone.repos.copyDirectory(this.appId, {
+          sourceDir: targetStateId,
+          destDir: newId,
+          sourceBranch: this.profileId,
+          destBranch: this.profileId,
+          transforms,
+          archive: true
+        });
+        const status = await this.waitForCopyRun(copyJob.runId, "state clone");
+        if (status?.result?.noChanges === true) return false;
+      } else {
+        const app = await this.client.request("GET", `/app/${this.appId}`);
+        const headVersionId = app.data.headVersionId;
+        if (typeof headVersionId !== "string" || !headVersionId.trim()) {
+          throw new HarnesslayerResponseError("Missing headVersionId for app");
+        }
+        try {
+          const branch = await this.driftstone.repos.createBranch(this.appId, this.profileId, {
+            storageDir: newId,
+            transforms,
+            archive: true
+          });
+          await this.waitForCopyRun(branch.runId ?? null, "state clone");
+        } catch (error) {
+          if (!(error instanceof Error) || !error.message.toLowerCase().includes("same name already exists")) {
+            throw error;
+          }
+          const copyJob = await this.driftstone.repos.copyDirectory(this.appId, {
+            sourceDir: headVersionId.trim(),
+            destDir: newId,
+            sourceBranch: "main",
+            destBranch: this.profileId,
+            transforms,
+            archive: true
+          });
+          const status = await this.waitForCopyRun(copyJob.runId, "state clone");
+          if (status?.result?.noChanges === true) return false;
+        }
+      }
+      await this.client.request("POST", "/state/create", { profileId: this.profileId, stateId: newId });
+      return true;
+    } catch (error) {
+      if (error instanceof HarnesslayerError) return false;
+      throw error;
+    }
+  }
+  async waitForCopyRun(runId, operation) {
+    if (!runId) return null;
+    const deadline = Date.now() + Math.max(this.client.timeoutMs, 1e3);
+    while (true) {
+      const status = await this.driftstone.repos.getCopyStatus(this.appId, runId);
+      if (status.status === "completed") return status;
+      if (status.status === "failed") {
+        throw new HarnesslayerAPIError(String(status.result?.error ?? `${operation} failed`));
+      }
+      if (status.status !== "running") {
+        throw new HarnesslayerResponseError(`Unexpected ${operation} status: ${status.status}`);
+      }
+      if (Date.now() >= deadline) {
+        throw new HarnesslayerAPIError(`Timed out waiting for ${operation} run ${runId}`);
+      }
+      await sleep(1e3);
+    }
+  }
+  async resolveStateId(stateId) {
+    const target = await this.tryResolveStateId(stateId);
+    if (!target) throw new HarnesslayerError("stateId must be provided or profile must have a head state");
+    if (!target.startsWith("state-")) throw new HarnesslayerError("stateId is invalid");
+    return target;
+  }
+  async tryResolveStateId(stateId) {
+    let target = typeof stateId === "string" ? stateId.trim() : "";
+    if (!target) {
+      const profile = await this.client.request("GET", `/profile/${this.profileId}`);
+      const headStateId = profile.data.headStateId;
+      if (typeof headStateId === "string" && headStateId.trim()) target = headStateId.trim();
+    }
+    return target || null;
+  }
+};
+
+// src/resources/profile.ts
+var HarnesslayerProfile = class extends AppBase {
+  async init(identifier, options = {}) {
+    const payload = {
+      appId: this.appId,
+      identifier: requireNonEmptyString(identifier, "identifier"),
+      returnIfExist: true
+    };
+    if (options.accessGroupId != null) payload.accessGroupId = requireNonEmptyString(options.accessGroupId, "accessGroupId");
+    if (options.metadata != null) {
+      if (typeof options.metadata !== "object" || Array.isArray(options.metadata)) {
+        throw new HarnesslayerError("metadata must be an object");
+      }
+      payload.metadata = options.metadata;
+    }
+    let pathData = null;
+    if (options.statePath != null) {
+      pathData = await validateConfigPath(requireNonEmptyString(options.statePath, "statePath"));
+      const app = await this.client.request("GET", `/app/${this.appId}`);
+      const appType = app.data.type;
+      if (pathData.type !== appType) {
+        throw new HarnesslayerError(`app type '${String(appType)}' does not match statePath type '${pathData.type}'`);
+      }
+    }
+    const response = await this.client.request("POST", "/profile/create", payload);
+    const data = response.data;
+    const state = new HarnesslayerState(this.client, this.appId, String(data.id));
+    const profile = profileFromApi(data, state);
+    if (!response.exists) {
+      const stateId = newStateId();
+      if (!pathData) {
+        const branch = await this.driftstone.repos.createBranch(this.appId, String(data.id), {
+          storageDir: stateId,
+          archive: true
+        });
+        await state.waitForCopyRun(branch.runId ?? null, "profile init");
+        await state.create({ stateId });
+      } else {
+        await this.driftstone.repos.createBranch(this.appId, String(data.id), {
+          storageDir: newStateId()
+        });
+        const files = await createUploadFilesPayload(pathData.path);
+        const repo = await this.driftstone.repos.get(this.appId);
+        const upload = await this.driftstone.repos.createUpload(repo.id, {
+          branch: String(data.id),
+          storageDir: stateId,
+          files
+        });
+        await this.driftstone.uploadFiles(upload, files, pathData.path);
+        await this.driftstone.repos.completeUpload(repo.id, upload.uploadId);
+        await state.create({ stateId });
+      }
+    }
+    return profile;
+  }
+  async retrieve(profileId) {
+    try {
+      const id = requireNonEmptyString(profileId, "profileId");
+      const response = await this.client.request("GET", `/profile/${id}`);
+      const state = new HarnesslayerState(this.client, this.appId, id);
+      return profileFromApi(response.data, state);
+    } catch (error) {
+      if (error instanceof HarnesslayerError) return null;
+      throw error;
+    }
+  }
+  async update(profileId, options) {
+    const id = requireNonEmptyString(profileId, "profileId");
+    const payload = {};
+    if (options.identifier != null) payload.identifier = requireNonEmptyString(options.identifier, "identifier");
+    if (options.accessGroupId != null) payload.accessGroupId = requireNonEmptyString(options.accessGroupId, "accessGroupId");
+    if (options.metadata != null) {
+      if (typeof options.metadata !== "object" || Array.isArray(options.metadata)) throw new HarnesslayerError("metadata must be an object");
+      payload.metadata = options.metadata;
+    }
+    if (!Object.keys(payload).length) throw new HarnesslayerError("At least one field must be provided to update");
+    const response = await this.client.request("PATCH", `/profile/${id}`, payload);
+    const state = new HarnesslayerState(this.client, this.appId, String(response.data.id));
+    return profileFromApi(response.data, state);
+  }
+  state(profileId) {
+    return new HarnesslayerState(this.client, this.appId, requireNonEmptyString(profileId, "profileId"));
+  }
+  async delete(profileId) {
+    await this.client.request("DELETE", `/profile/${requireNonEmptyString(profileId, "profileId")}`);
+    return true;
+  }
+};
+
+// src/resources/session.ts
+var HarnesslayerSession = class extends AppBase {
+  async create(type) {
+    if (!["api", "imessage"].includes(type)) throw new HarnesslayerError("type must be either 'api' or 'imessage'");
+    const response = await this.client.request("POST", "/session/create", { appId: this.appId, type });
+    return sessionFromApi(response.data);
+  }
+  async retrieve(sessionId) {
+    try {
+      const response = await this.client.request("GET", `/session/${requireNonEmptyString(sessionId, "sessionId")}`);
+      return sessionFromApi(response.data);
+    } catch (error) {
+      if (error instanceof HarnesslayerAPIError || error instanceof HarnesslayerHTTPError || error instanceof HarnesslayerResponseError) {
+        throw error;
+      }
+      if (error instanceof HarnesslayerError) return null;
+      throw error;
+    }
+  }
+  async update(sessionId, options) {
+    const payload = {};
+    if (options.type != null) {
+      if (!["single", "multiple"].includes(options.type)) throw new HarnesslayerError("type must be either 'single' or 'multiple'");
+      payload.type = options.type;
+    }
+    if (options.userIds != null) {
+      if (!Array.isArray(options.userIds) || !options.userIds.every((id) => typeof id === "string" && id.trim())) {
+        throw new HarnesslayerError("userIds must be a list of non-empty strings");
+      }
+      payload.userIds = options.userIds;
+    }
+    if (!Object.keys(payload).length) throw new HarnesslayerError("At least one of 'type' or 'userIds' must be provided");
+    const response = await this.client.request("PATCH", `/session/${requireNonEmptyString(sessionId, "sessionId")}`, payload);
+    return sessionFromApi(response.data);
+  }
+  async list(options = {}) {
+    const response = await this.client.request("GET", "/session/list", {
+      appId: this.appId,
+      page: validatePositiveInteger(options.page ?? 1, "page"),
+      pageSize: validatePositiveInteger(options.pageSize ?? 10, "pageSize")
+    });
+    if (!Array.isArray(response.data)) throw new HarnesslayerError("Expected 'data' to be a list in session list response");
+    return response.data.map((item) => sessionFromApi(item));
+  }
+  async delete(sessionId) {
+    await this.client.request("DELETE", `/session/${requireNonEmptyString(sessionId, "sessionId")}`);
+    return true;
+  }
+};
+
+// src/resources/version.ts
+var HarnesslayerVersion = class extends AppBase {
+  async create(options) {
+    if (!options.versionId && !options.versionPath) {
+      throw new HarnesslayerError("Either versionId or versionPath must be provided");
+    }
+    const payload = { appId: this.appId };
+    if (options.versionId) {
+      if (!options.versionId.startsWith("ver-")) throw new HarnesslayerError("versionId is invalid");
+      payload.versionId = options.versionId;
+    } else if (options.versionPath) {
+      const versionId = newVersionId();
+      const pathData = await validateConfigPath(options.versionPath);
+      const files = await createUploadFilesPayload(pathData.path);
+      const repo = await this.driftstone.repos.get(this.appId);
+      const upload = await this.driftstone.repos.createUpload(repo.id, {
+        branch: "main",
+        storageDir: versionId,
+        files
+      });
+      await this.driftstone.uploadFiles(upload, files, pathData.path);
+      await this.driftstone.repos.completeUpload(repo.id, upload.uploadId);
+      payload.versionId = versionId;
+    }
+    await this.client.request("POST", "/version/create", payload);
+    return true;
+  }
+  async download(outPath, versionId) {
+    const targetVersionId = await this.resolveVersionId(versionId);
+    const response = await this.client.request("GET", `/version/download/${targetVersionId}`);
+    const url = response.data.url;
+    if (typeof url !== "string" || !url.trim()) {
+      throw new HarnesslayerResponseError("Missing download URL for version");
+    }
+    const archive = await fetch(url, { redirect: "follow" });
+    if (archive.status >= 400) throw new HarnesslayerAPIError("Failed to download version archive");
+    await extractZip(new Uint8Array(await archive.arrayBuffer()), outPath);
+    return true;
+  }
+  async clone(options = {}) {
+    try {
+      const targetVersionId = await this.resolveVersionId(options.versionId);
+      const newId = newVersionId();
+      const copyJob = await this.driftstone.repos.copyDirectory(this.appId, {
+        sourceDir: targetVersionId,
+        destDir: newId,
+        transforms: validateCloneTransform(options.transform),
+        archive: true
+      });
+      const deadline = Date.now() + Math.max(this.client.timeoutMs, 1e3);
+      while (true) {
+        const status = await this.driftstone.repos.getCopyStatus(this.appId, copyJob.runId);
+        if (status.status === "completed") {
+          if (status.result?.noChanges === true) return false;
+          break;
+        }
+        if (status.status === "failed") {
+          throw new HarnesslayerAPIError(String(status.result?.error ?? "Version clone failed"));
+        }
+        if (status.status !== "running") {
+          throw new HarnesslayerResponseError(`Unexpected version clone status: ${status.status}`);
+        }
+        if (Date.now() >= deadline) {
+          throw new HarnesslayerAPIError(`Timed out waiting for version clone run ${copyJob.runId}`);
+        }
+        await sleep(1e3);
+      }
+      await this.client.request("POST", "/version/create", { appId: this.appId, versionId: newId });
+      return true;
+    } catch (error) {
+      if (error instanceof HarnesslayerError) return false;
+      throw error;
+    }
+  }
+  async sync(strategy = "manual") {
+    if (!["manual", "current", "incoming", "smart"].includes(strategy)) {
+      throw new HarnesslayerError("Invalid sync strategy");
+    }
+    const response = await this.client.request("POST", "/version/sync", {
+      appId: this.appId,
+      strategy
+    });
+    if (response.error) throw new HarnesslayerAPIError(`Failed to sync version: ${String(response.error)}`);
+    return true;
+  }
+  async resolveVersionId(versionId) {
+    let target = typeof versionId === "string" ? versionId.trim() : "";
+    if (!target) {
+      const app = await this.client.request("GET", `/app/${this.appId}`);
+      const headVersionId = app.data.headVersionId;
+      if (typeof headVersionId !== "string" || !headVersionId.trim()) {
+        throw new HarnesslayerResponseError("Missing headVersionId for app");
+      }
+      target = headVersionId.trim();
+    }
+    if (!target.startsWith("ver-")) throw new HarnesslayerError("versionId is invalid");
+    return target;
+  }
+};
+
+// src/resources/app.ts
+var HarnesslayerApp = class extends ResourceBase {
+  async init(slug, options) {
+    if (!["claude", "openclaw"].includes(options.type)) {
+      throw new HarnesslayerError("type must be one of 'claude', 'openclaw'");
+    }
+    const payload = {
+      slug: validateSlug(slug),
+      type: options.type,
+      returnIfExist: true
+    };
+    if (options.name != null) payload.name = requireNonEmptyString(options.name, "name");
+    if (options.limit != null) {
+      if (typeof options.limit !== "object" || Array.isArray(options.limit) || options.limit.amount == null || options.limit.interval == null) {
+        throw new HarnesslayerError("limit must be an object with 'amount' and 'interval' keys");
+      }
+      payload.limit = options.limit;
+    }
+    if (options.credentials != null) {
+      if (!Array.isArray(options.credentials) || !options.credentials.every((item) => item && typeof item === "object")) {
+        throw new HarnesslayerError("credentials must be a list of objects");
+      }
+      payload.credentials = options.credentials;
+    }
+    const createResponse = await this.client.request("POST", "/app/create", payload);
+    const app = this.buildAppModel(createResponse.data);
+    if (!createResponse.exists) {
+      const pathData = await validateConfigPath(requireNonEmptyString(options.versionPath, "versionPath"));
+      if (pathData.type !== options.type) {
+        throw new HarnesslayerError(`type '${options.type}' does not match versionPath type '${pathData.type}'`);
+      }
+      const versionId = newVersionId();
+      const files = await createUploadFilesPayload(pathData.path);
+      const repo = await this.driftstone.repos.create(String(createResponse.data.id));
+      const upload = await this.driftstone.repos.createUpload(repo.id, {
+        branch: "main",
+        storageDir: versionId,
+        files
+      });
+      await this.driftstone.uploadFiles(upload, files, pathData.path);
+      await this.driftstone.repos.completeUpload(repo.id, upload.uploadId);
+      await app.version.create({ versionId });
+    }
+    return app;
+  }
+  async retrieve(options) {
+    try {
+      const appId = options.appId?.trim();
+      const slug = options.slug?.trim();
+      if (!appId && !slug) throw new HarnesslayerError("Either appId or slug must be provided");
+      if (appId && slug) throw new HarnesslayerError("Only one of appId or slug can be provided, not both");
+      const response = await this.client.request("GET", `/app/${appId ?? slug}`);
+      return this.buildAppModel(response.data);
+    } catch (error) {
+      if (error instanceof HarnesslayerError) return null;
+      throw error;
+    }
+  }
+  async delete(appId) {
+    await this.client.request("DELETE", `/app/${requireNonEmptyString(appId, "appId")}`);
+    return true;
+  }
+  channel(appId) {
+    return new HarnesslayerChannel(this.client, requireNonEmptyString(appId, "appId"));
+  }
+  instance(appId) {
+    return new HarnesslayerInstance(this.client, requireNonEmptyString(appId, "appId"));
+  }
+  accessGroup(appId) {
+    return new HarnesslayerAccessGroup(this.client, requireNonEmptyString(appId, "appId"));
+  }
+  profile(appId) {
+    return new HarnesslayerProfile(this.client, requireNonEmptyString(appId, "appId"));
+  }
+  conflict(appId) {
+    return new HarnesslayerConflict(this.client, requireNonEmptyString(appId, "appId"));
+  }
+  buildAppModel(appData) {
+    const appId = String(appData.id);
+    return appFromApi(appData, {
+      version: new HarnesslayerVersion(this.client, appId),
+      channel: new HarnesslayerChannel(this.client, appId),
+      session: new HarnesslayerSession(this.client, appId),
+      accessGroup: new HarnesslayerAccessGroup(this.client, appId),
+      profile: new HarnesslayerProfile(this.client, appId),
+      instance: new HarnesslayerInstance(this.client, appId),
+      conflict: new HarnesslayerConflict(this.client, appId)
+    });
+  }
+};
+
+// src/resources/organization.ts
+var HarnesslayerOrganization = class extends ResourceBase {
+  async create(name, options) {
+    const response = await this.client.request("POST", "/organization/create", {
+      name: requireNonEmptyString(name, "name"),
+      slug: validateSlug(options.slug)
+    });
+    return organizationFromApi(response.data);
+  }
+  async init(name, options) {
+    if (options.returnIfExist != null && options.return_if_exist != null) {
+      throw new HarnesslayerError("Only one of returnIfExist or return_if_exist may be provided");
+    }
+    const response = await this.client.request("POST", "/organization/create", {
+      name: requireNonEmptyString(name, "name"),
+      slug: validateSlug(options.slug),
+      returnIfExist: options.returnIfExist ?? options.return_if_exist ?? false
+    });
+    return organizationFromApi(response.data);
+  }
+  async update(organizationId, options) {
+    const payload = {};
+    if (options.name != null) payload.name = requireNonEmptyString(options.name, "name");
+    if (options.slug != null) payload.slug = validateSlug(options.slug);
+    if (!Object.keys(payload).length) throw new HarnesslayerError("At least one field must be provided to update");
+    const response = await this.client.request(
+      "PATCH",
+      `/organization/${requireNonEmptyString(organizationId, "organizationId")}`,
+      payload
+    );
+    return organizationFromApi(response.data);
+  }
+};
+
+// src/resources/response.ts
+var HarnesslayerResponse = class extends ResourceBase {
+  async stop(instanceId) {
+    const response = await this.client.request("POST", "/response/stop", {
+      instanceId: requireNonEmptyString(instanceId, "instanceId")
+    });
+    if (!response.data || typeof response.data !== "object" || Array.isArray(response.data)) {
+      throw new HarnesslayerError("Expected 'data' to be an object in response stop response");
+    }
+    return response.data;
+  }
+};
+
+// src/client.ts
+var Harnesslayer = class {
+  apiKey;
+  apiVersion;
+  timeoutMs;
+  baseUrl;
+  driftstone;
+  transport;
+  constructor(apiKeyOrOptions, maybeOptions = {}) {
+    const options = typeof apiKeyOrOptions === "string" ? { ...maybeOptions, apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+    const apiKey = options.apiKey.trim();
+    if (!apiKey) throw new HarnesslayerError("apiKey must be provided");
+    if (!apiKey.startsWith("dk-")) throw new HarnesslayerError("Invalid Harnesslayer API key");
+    this.apiKey = apiKey;
+    this.apiVersion = options.version ?? "v1";
+    this.timeoutMs = options.timeoutMs ?? (options.timeout != null ? options.timeout * 1e3 : 6e5);
+    this.baseUrl = `${(options.baseUrl ?? DEFAULT_API_BASE_URL).replace(/\/+$/, "")}/${this.apiVersion}`;
+    const transportOptions = {
+      baseUrl: this.baseUrl,
+      apiKey: this.apiKey,
+      timeoutMs: this.timeoutMs,
+      userAgent: "Harnesslayer-typescript/0.1.0",
+      ...options.fetch ? { fetch: options.fetch } : {}
+    };
+    this.transport = new Transport(transportOptions);
+    const driftstoneOptions = {
+      apiKey: this.apiKey,
+      version: this.apiVersion,
+      timeoutMs: this.timeoutMs,
+      ...options.fetch ? { fetch: options.fetch } : {},
+      ...options.driftstoneBaseUrl ? { baseUrl: options.driftstoneBaseUrl } : {}
+    };
+    this.driftstone = new DriftstoneClient(driftstoneOptions);
+  }
+  request(method, path4, payload) {
+    return this.transport.request(method, path4, payload);
+  }
+  get app() {
+    return new HarnesslayerApp(this);
+  }
+  get organization() {
+    return new HarnesslayerOrganization(this);
+  }
+  get response() {
+    return new HarnesslayerResponse(this);
+  }
+};
+export {
+  DriftstoneAPIError,
+  DriftstoneError,
+  DriftstoneHTTPError,
+  DriftstoneResponseError,
+  Harnesslayer,
+  HarnesslayerAPIError,
+  HarnesslayerAccessGroup,
+  HarnesslayerApp,
+  HarnesslayerChannel,
+  HarnesslayerConflict,
+  HarnesslayerError,
+  HarnesslayerHTTPError,
+  HarnesslayerInstance,
+  HarnesslayerOrganization,
+  HarnesslayerProfile,
+  HarnesslayerResponse,
+  HarnesslayerResponseError,
+  HarnesslayerSession,
+  HarnesslayerState,
+  HarnesslayerVersion,
+  Harnesslayer as default
+};
+//# sourceMappingURL=index.js.map