@bryanhu/codexly 0.1.0

package/dist/client/index.js

@@ -0,0 +1,1010 @@
+import { createRequire } from 'node:module';
+import { value_exports } from '../chunk-TEPSAXZZ.js';
+import { EventStreamMessageSchema, TEMPORARY_TASK_SCOPE_ID, TEMPORARY_TASK_API_PATH, AgentQueuedSubmissionPageSchema, AddAgentQueuedSubmissionResponseSchema, UpdateAgentQueuedSubmissionResponseSchema, DeleteAgentQueuedSubmissionResponseSchema, ReorderAgentQueuedSubmissionsResponseSchema, StartAgentQueuedSubmissionResponseSchema, AgentTaskPageSchema, AgentTaskSnapshotResponseSchema, OpenAgentTaskAttachmentResponseSchema, AgentBackgroundTerminalPageSchema, TerminateAgentBackgroundTerminalResponseSchema, AgentTaskSettingsResponseSchema, StartAgentTaskResponseSchema, PinAgentTaskResponseSchema, RenameAgentTaskResponseSchema, UnsubscribeAgentTaskResponseSchema, ReviewAgentTaskResponseSchema, CompactAgentTaskResponseSchema, ForkAgentTaskResponseSchema, UploadAgentFeedbackResponseSchema, AgentAttachmentUploadResponseSchema, AgentMutationErrorSchema, StartAgentTurnResponseSchema, SteerAgentTurnResponseSchema, InterruptAgentTurnResponseSchema, ResolvePendingRequestResponseSchema, ArchiveAgentTaskResponseSchema, UnarchiveAgentTaskResponseSchema, DeleteAgentTaskResponseSchema, AgentSkillPageSchema, AgentMcpServerPageSchema, ReloadAgentMcpServersResponseSchema, ProjectPageSchema, ProjectDirectoryListingSchema, HostFileListingSchema, ReorderProjectsResponseSchema, AgentProjectDefaultsResponseSchema, AddProjectResponseSchema, RenameProjectResponseSchema, RemoveProjectResponseSchema, ProjectOpenCapabilitiesResponseSchema, OpenProjectResponseSchema, ProjectGitStatusSchema, ProjectGitHistoryPageSchema, ProjectGitCommitFilesPageSchema, ProjectGitCommitFileDiffSchema, ProjectGitWorktreePageSchema, ProjectWorktreeMutationResponseSchema, GenerateCommitMessageResponseSchema, CommitProjectChangesResponseSchema, ProjectFileTreeSchema, ProjectFileSearchPageSchema, StopProjectFileSearchResponseSchema, ProjectSourceFileSchema, HealthResponseSchema, AppInfoResponseSchema, InstallAppUpdateResponseSchema, AccessStatusResponseSchema, AgentCapabilitiesSchema, AgentModelPageSchema, AgentProviderConnectionStatusSchema, StartOfficialProviderLoginResponseSchema, AgentProviderConnectionMutationResponseSchema, ConfigureCustomProviderResponseSchema, AgentGlobalSettingsResponseSchema } from '../chunk-MH54VCZJ.js';
+import '../chunk-K6J42667.js';
+
+createRequire(import.meta.url);
+
+// packages/client/src/event-client.ts
+var CodexlyEventError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodexlyEventError";
+  }
+};
+function createEventUrl(baseUrl, projectId, afterSequence) {
+  const path = projectId === TEMPORARY_TASK_SCOPE_ID ? `${TEMPORARY_TASK_API_PATH}/events` : `/v1/projects/${encodeURIComponent(projectId)}/events`;
+  const httpUrl = baseUrl ? new URL(`${baseUrl}${path}`) : new URL(path, globalThis.location.href);
+  httpUrl.protocol = httpUrl.protocol === "https:" ? "wss:" : "ws:";
+  httpUrl.searchParams.set("afterSequence", String(afterSequence));
+  return httpUrl.toString();
+}
+function createResyncRequired(sessionId, latestSequence, reason) {
+  return {
+    latestSequence,
+    reason,
+    sessionId,
+    type: "resync.required",
+    version: 3
+  };
+}
+function startAgentEventSubscription(options) {
+  const reconnectDelayMs = options.reconnectDelayMs ?? 250;
+  let active = true;
+  let allowReconnect = true;
+  let lastSequence = options.afterSequence;
+  let reconnectAttempt = 0;
+  let retryTimer;
+  let socket;
+  let detachSocketListeners;
+  const setState = (state) => {
+    options.onConnectionState?.(state);
+  };
+  const closeSocket = (code, reason) => {
+    const currentSocket = socket;
+    if (currentSocket === void 0) {
+      return;
+    }
+    detachSocketListeners?.();
+    detachSocketListeners = void 0;
+    socket = void 0;
+    currentSocket.close(code, reason);
+  };
+  const stopForResync = (message) => {
+    allowReconnect = false;
+    options.onResyncRequired(message);
+    closeSocket(1e3, "Snapshot resync required");
+    setState("closed");
+  };
+  const failProtocol = (message, cause) => {
+    allowReconnect = false;
+    options.onError?.(new CodexlyEventError(message, cause === void 0 ? void 0 : { cause }));
+    closeSocket(1002, "Invalid Agent Event frame");
+    setState("closed");
+  };
+  const connect = () => {
+    if (!active) {
+      return;
+    }
+    retryTimer = void 0;
+    let connectionReady = false;
+    const currentSocket = options.webSocketFactory(
+      createEventUrl(options.baseUrl, options.projectId, lastSequence)
+    );
+    socket = currentSocket;
+    const isCurrentConnection = () => active && socket === currentSocket;
+    const onMessage = (event) => {
+      if (!isCurrentConnection()) {
+        return;
+      }
+      let frame;
+      try {
+        frame = JSON.parse(String(event.data));
+      } catch (error) {
+        failProtocol("Codexly event frame is not valid JSON", error);
+        return;
+      }
+      if (!value_exports.Check(EventStreamMessageSchema, frame)) {
+        failProtocol("Codexly event frame does not match the protocol schema");
+        return;
+      }
+      const message = frame;
+      if (message.type === "resync.required") {
+        stopForResync(message);
+        return;
+      }
+      if (message.type === "connection.ready") {
+        if (message.sessionId !== options.sessionId || message.latestSequence < lastSequence) {
+          stopForResync(
+            createResyncRequired(message.sessionId, message.latestSequence, "session_changed")
+          );
+          return;
+        }
+        connectionReady = true;
+        reconnectAttempt = 0;
+        setState("connected");
+        return;
+      }
+      if (!connectionReady) {
+        failProtocol("Codexly event arrived before connection.ready");
+        return;
+      }
+      for (const agentEvent of message.events) {
+        if (agentEvent.sessionId !== options.sessionId) {
+          stopForResync(
+            createResyncRequired(agentEvent.sessionId, agentEvent.sequence, "session_changed")
+          );
+          return;
+        }
+        if (agentEvent.sequence <= lastSequence) {
+          continue;
+        }
+        if (agentEvent.sequence !== lastSequence + 1) {
+          stopForResync(
+            createResyncRequired(agentEvent.sessionId, agentEvent.sequence, "sequence_gap")
+          );
+          return;
+        }
+        lastSequence = agentEvent.sequence;
+        options.onEvent(agentEvent);
+        if (!isCurrentConnection()) {
+          return;
+        }
+      }
+    };
+    const onError = () => {
+      if (!active || socket !== currentSocket) {
+        return;
+      }
+      options.onError?.(new CodexlyEventError("Codexly event connection failed"));
+    };
+    const onClose = () => {
+      if (socket !== currentSocket) {
+        return;
+      }
+      detachSocketListeners?.();
+      detachSocketListeners = void 0;
+      socket = void 0;
+      if (!active) {
+        return;
+      }
+      if (!allowReconnect) {
+        setState("closed");
+        return;
+      }
+      setState("reconnecting");
+      const delay = Math.min(reconnectDelayMs * 2 ** reconnectAttempt, 5e3);
+      reconnectAttempt += 1;
+      retryTimer = setTimeout(connect, delay);
+    };
+    detachSocketListeners = () => {
+      currentSocket.removeEventListener("message", onMessage);
+      currentSocket.removeEventListener("error", onError);
+      currentSocket.removeEventListener("close", onClose);
+    };
+    currentSocket.addEventListener("message", onMessage);
+    currentSocket.addEventListener("error", onError);
+    currentSocket.addEventListener("close", onClose);
+  };
+  setState("connecting");
+  connect();
+  return () => {
+    if (!active) {
+      return;
+    }
+    active = false;
+    allowReconnect = false;
+    if (retryTimer !== void 0) {
+      clearTimeout(retryTimer);
+    }
+    closeSocket(1e3, "Subscription cancelled");
+    setState("closed");
+  };
+}
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/stringify.js
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) {
+  byteToHex.push((i + 256).toString(16).slice(1));
+}
+function unsafeStringify(arr, offset = 0) {
+  return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/rng.js
+var rnds8 = new Uint8Array(16);
+function rng() {
+  return crypto.getRandomValues(rnds8);
+}
+
+// node_modules/.pnpm/uuid@14.0.1/node_modules/uuid/dist-node/v4.js
+function v4(options, buf, offset) {
+  if (!buf && !options && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return _v4(options, buf, offset);
+}
+function _v4(options, buf, offset) {
+  options = options || {};
+  const rnds = options.random ?? options.rng?.() ?? rng();
+  if (rnds.length < 16) {
+    throw new Error("Random bytes length must be >= 16");
+  }
+  rnds[6] = rnds[6] & 15 | 64;
+  rnds[8] = rnds[8] & 63 | 128;
+  if (buf) {
+    offset = offset || 0;
+    if (offset < 0 || offset + 16 > buf.length) {
+      throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+    }
+    for (let i = 0; i < 16; ++i) {
+      buf[offset + i] = rnds[i];
+    }
+    return buf;
+  }
+  return unsafeStringify(rnds);
+}
+var v4_default = v4;
+
+// packages/client/src/http-client-transport.ts
+var APP_UPDATE_REQUEST_TIMEOUT_MS = 15e4;
+var CodexlyHttpError = class extends Error {
+  status;
+  constructor(status, statusText, message) {
+    super(message ?? `Codexly request failed with ${String(status)} ${statusText}`.trim());
+    this.name = "CodexlyHttpError";
+    this.status = status;
+  }
+};
+var CodexlyMutationError = class extends CodexlyHttpError {
+  code;
+  retryable;
+  constructor(status, statusText, error) {
+    super(status, statusText, error.message);
+    this.name = "CodexlyMutationError";
+    this.code = error.code;
+    this.retryable = error.retryable;
+  }
+};
+var CodexlyResponseError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "CodexlyResponseError";
+  }
+};
+function appendQuery(path, values) {
+  const query = new URLSearchParams();
+  for (const [key, value] of Object.entries(values)) {
+    if (value !== void 0) {
+      query.set(key, String(value));
+    }
+  }
+  const encoded = query.toString();
+  return encoded ? `${path}?${encoded}` : path;
+}
+function projectPath(projectId) {
+  if (projectId === TEMPORARY_TASK_SCOPE_ID) {
+    return TEMPORARY_TASK_API_PATH;
+  }
+  return `/v1/projects/${encodeURIComponent(projectId)}`;
+}
+function taskPath(projectId, taskId) {
+  return `${projectPath(projectId)}/tasks/${encodeURIComponent(taskId)}`;
+}
+function buildTaskAttachmentUrl(baseUrl, projectId, taskId, attachmentId) {
+  return `${baseUrl.replace(/\/$/u, "")}${taskPath(projectId, taskId)}/attachments/${encodeURIComponent(attachmentId)}`;
+}
+function buildProjectImageFileUrl(baseUrl, projectId, path, rootPath) {
+  const requestPath = appendQuery(`${projectPath(projectId)}/files/image`, { path, rootPath });
+  return `${baseUrl.replace(/\/$/u, "")}${requestPath}`;
+}
+function buildProjectAttachmentUrl(baseUrl, projectId, attachmentId) {
+  return `${baseUrl.replace(/\/$/u, "")}${projectPath(projectId)}/attachments/${encodeURIComponent(attachmentId)}`;
+}
+var CodexlyTransport = class {
+  baseUrl;
+  fetchImplementation;
+  requestTimeouts;
+  webSocketFactory;
+  unauthorizedListeners = /* @__PURE__ */ new Set();
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl?.replace(/\/$/u, "") ?? "";
+    this.fetchImplementation = options.fetch ?? globalThis.fetch.bind(globalThis);
+    this.requestTimeouts = {
+      mutationMs: options.requestTimeouts?.mutationMs ?? 6e4,
+      queryMs: options.requestTimeouts?.queryMs ?? 3e4,
+      readMs: options.requestTimeouts?.readMs ?? 15e3
+    };
+    this.webSocketFactory = options.webSocketFactory ?? ((url) => new WebSocket(url));
+  }
+  async getHealth(options = {}) {
+    return this.read("/v1/health", HealthResponseSchema, options);
+  }
+  async getAppInfo(options = {}) {
+    return this.read("/v1/app-info", AppInfoResponseSchema, options);
+  }
+  async installAppUpdate(version, options = {}) {
+    return this.mutation(
+      "/v1/app-update",
+      { version },
+      InstallAppUpdateResponseSchema,
+      options,
+      "POST",
+      APP_UPDATE_REQUEST_TIMEOUT_MS
+    );
+  }
+  async getAccessStatus(options = {}) {
+    return this.read("/v1/access", AccessStatusResponseSchema, options);
+  }
+  async pairAccess(code) {
+    return this.request(
+      "/v1/access/pair",
+      AccessStatusResponseSchema,
+      {
+        body: JSON.stringify({ code }),
+        headers: { "content-type": "application/json" },
+        method: "POST"
+      },
+      AgentMutationErrorSchema,
+      { timeoutMs: this.requestTimeouts.mutationMs }
+    );
+  }
+  async logoutAccess() {
+    return this.request(
+      "/v1/access/logout",
+      AccessStatusResponseSchema,
+      { body: "{}", headers: { "content-type": "application/json" }, method: "POST" },
+      AgentMutationErrorSchema,
+      { timeoutMs: this.requestTimeouts.mutationMs }
+    );
+  }
+  subscribeUnauthorized(listener) {
+    this.unauthorizedListeners.add(listener);
+    return () => this.unauthorizedListeners.delete(listener);
+  }
+  async getCapabilities(options = {}) {
+    return this.read("/v1/capabilities", AgentCapabilitiesSchema, options);
+  }
+  async listModels(options = {}) {
+    return this.read("/v1/models", AgentModelPageSchema, options);
+  }
+  async getProviderConnection(options = {}) {
+    return this.read("/v1/provider-connection", AgentProviderConnectionStatusSchema, options);
+  }
+  async startOfficialProviderLogin(options = {}) {
+    return this.mutation(
+      "/v1/provider-connection/official-login",
+      {},
+      StartOfficialProviderLoginResponseSchema,
+      options
+    );
+  }
+  async cancelProviderLogin(loginId, options = {}) {
+    return this.mutation(
+      "/v1/provider-connection/official-login/cancel",
+      { loginId },
+      AgentProviderConnectionMutationResponseSchema,
+      options
+    );
+  }
+  async configureCustomProvider(input, options = {}) {
+    return this.mutation(
+      "/v1/provider-connection/custom",
+      input,
+      ConfigureCustomProviderResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async logoutProvider(options = {}) {
+    return this.mutation(
+      "/v1/provider-connection/logout",
+      {},
+      AgentProviderConnectionMutationResponseSchema,
+      options
+    );
+  }
+  async getGlobalSettings(options = {}) {
+    return this.read("/v1/settings", AgentGlobalSettingsResponseSchema, options);
+  }
+  async updateGlobalSettings(settings, options = {}) {
+    return this.mutation(
+      "/v1/settings",
+      settings,
+      AgentGlobalSettingsResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  subscribeEvents(options) {
+    return startAgentEventSubscription({
+      ...options,
+      baseUrl: this.baseUrl,
+      webSocketFactory: this.webSocketFactory
+    });
+  }
+  mutation(path, body, schema, options, method = "POST", timeoutMs = this.requestTimeouts.mutationMs) {
+    return this.request(
+      path,
+      schema,
+      {
+        body: JSON.stringify(body),
+        headers: {
+          "content-type": "application/json",
+          "idempotency-key": options.idempotencyKey ?? v4_default()
+        },
+        method
+      },
+      AgentMutationErrorSchema,
+      {
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        timeoutMs
+      }
+    );
+  }
+  read(path, schema, options, errorSchema) {
+    return this.request(path, schema, {}, errorSchema, {
+      ...options.signal === void 0 ? {} : { signal: options.signal },
+      timeoutMs: options.signal === void 0 ? this.requestTimeouts.readMs : this.requestTimeouts.queryMs
+    });
+  }
+  async request(path, schema, init = {}, errorSchema, requestOptions = {}) {
+    const timeoutSignal = AbortSignal.timeout(
+      requestOptions.timeoutMs ?? this.requestTimeouts.readMs
+    );
+    const signal = requestOptions.signal === void 0 ? timeoutSignal : AbortSignal.any([requestOptions.signal, timeoutSignal]);
+    const response = await this.fetchImplementation(`${this.baseUrl}${path}`, {
+      ...init,
+      credentials: "same-origin",
+      headers: { accept: "application/json", ...init.headers },
+      signal
+    });
+    if (!response.ok) {
+      if (response.status === 401) {
+        for (const listener of this.unauthorizedListeners) {
+          try {
+            listener();
+          } catch {
+          }
+        }
+      }
+      if (errorSchema !== void 0) {
+        let errorBody;
+        try {
+          errorBody = await response.json();
+        } catch (error) {
+          throw new CodexlyResponseError("Codexly error response is not valid JSON", {
+            cause: error
+          });
+        }
+        if (!value_exports.Check(errorSchema, errorBody)) {
+          throw new CodexlyResponseError(
+            "Codexly error response does not match the protocol schema"
+          );
+        }
+        throw new CodexlyMutationError(
+          response.status,
+          response.statusText,
+          errorBody
+        );
+      }
+      try {
+        const errorBody = await response.json();
+        if (typeof errorBody === "object" && errorBody !== null && "message" in errorBody && typeof errorBody.message === "string" && errorBody.message.length > 0) {
+          throw new CodexlyHttpError(response.status, response.statusText, errorBody.message);
+        }
+      } catch (error) {
+        if (error instanceof CodexlyHttpError) throw error;
+      }
+      throw new CodexlyHttpError(response.status, response.statusText);
+    }
+    let body;
+    try {
+      body = await response.json();
+    } catch (error) {
+      throw new CodexlyResponseError("Codexly response is not valid JSON", { cause: error });
+    }
+    if (!value_exports.Check(schema, body)) {
+      throw new CodexlyResponseError("Codexly response does not match the protocol schema");
+    }
+    return body;
+  }
+};
+
+// packages/client/src/http-client-projects.ts
+var ProjectHttpClient = class extends CodexlyTransport {
+  async listSkills(projectId, options = {}) {
+    return this.read(`${projectPath(projectId)}/skills`, AgentSkillPageSchema, options);
+  }
+  async listMcpServers(projectId, taskId, options = {}) {
+    return this.read(
+      `${taskPath(projectId, taskId)}/mcp-servers`,
+      AgentMcpServerPageSchema,
+      options,
+      AgentMutationErrorSchema
+    );
+  }
+  async retryMcpServers(projectId, taskId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/mcp-servers/retry`,
+      {},
+      ReloadAgentMcpServersResponseSchema,
+      options
+    );
+  }
+  async listProjects(options = {}) {
+    return this.read("/v1/projects", ProjectPageSchema, options);
+  }
+  async listProjectDirectories(path, options = {}) {
+    return this.read(
+      appendQuery("/v1/project-directories", {
+        path,
+        includeHidden: options.includeHidden === true ? "true" : void 0
+      }),
+      ProjectDirectoryListingSchema,
+      options
+    );
+  }
+  async listHostFiles(kind, path, options = {}) {
+    return this.read(
+      appendQuery("/v1/host-files", {
+        kind,
+        path,
+        includeHidden: options.includeHidden === true ? "true" : void 0
+      }),
+      HostFileListingSchema,
+      options
+    );
+  }
+  async reorderProjects(projectIds, options = {}) {
+    return this.mutation(
+      "/v1/projects/order",
+      { projectIds },
+      ReorderProjectsResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async getProjectDefaults(projectId, options = {}) {
+    return this.read(
+      `${projectPath(projectId)}/defaults`,
+      AgentProjectDefaultsResponseSchema,
+      options
+    );
+  }
+  async updateProjectDefaults(projectId, settings, options = {}) {
+    return this.mutation(
+      `${projectPath(projectId)}/defaults`,
+      settings,
+      AgentProjectDefaultsResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async addProject(rootPaths, options = {}) {
+    return this.mutation(
+      "/v1/projects",
+      { roots: rootPaths.map((path) => ({ path })) },
+      AddProjectResponseSchema,
+      options
+    );
+  }
+  async renameProject(projectId, name, options = {}) {
+    return this.mutation(
+      `${projectPath(projectId)}/rename`,
+      { name },
+      RenameProjectResponseSchema,
+      options
+    );
+  }
+  async removeProject(projectId, options = {}) {
+    return this.mutation(
+      `${projectPath(projectId)}/remove`,
+      {},
+      RemoveProjectResponseSchema,
+      options
+    );
+  }
+  async getProjectOpenCapabilities(projectId, options = {}) {
+    return this.read(
+      `${projectPath(projectId)}/open-capabilities`,
+      ProjectOpenCapabilitiesResponseSchema,
+      options
+    );
+  }
+  async openProject(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/open`, { rootPath }),
+      request,
+      OpenProjectResponseSchema,
+      options
+    );
+  }
+  async getProjectGitStatus(projectId, query, options = {}) {
+    return this.read(
+      appendQuery(`/v1/projects/${encodeURIComponent(projectId)}/git/status`, {
+        includeDiff: query.includeDiff === true ? "true" : void 0,
+        repository: query.repository,
+        rootPath: query.rootPath
+      }),
+      ProjectGitStatusSchema,
+      options
+    );
+  }
+  async getProjectGitHistory(projectId, query, options = {}) {
+    return this.read(
+      appendQuery(`${projectPath(projectId)}/git/history`, {
+        cursor: query.cursor,
+        repository: query.repository,
+        rootPath: query.rootPath
+      }),
+      ProjectGitHistoryPageSchema,
+      options
+    );
+  }
+  async getProjectGitCommitFiles(projectId, query, options = {}) {
+    return this.read(
+      appendQuery(`${projectPath(projectId)}/git/commit-files`, {
+        cursor: query.cursor,
+        repository: query.repository,
+        rootPath: query.rootPath,
+        sha: query.sha
+      }),
+      ProjectGitCommitFilesPageSchema,
+      options
+    );
+  }
+  async getProjectGitCommitFileDiff(projectId, query, options = {}) {
+    return this.read(
+      appendQuery(`${projectPath(projectId)}/git/commit-diff`, {
+        path: query.path,
+        repository: query.repository,
+        rootPath: query.rootPath,
+        sha: query.sha
+      }),
+      ProjectGitCommitFileDiffSchema,
+      options
+    );
+  }
+  async switchProjectBranch(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/git/branch`, { rootPath }),
+      request,
+      ProjectGitStatusSchema,
+      options
+    );
+  }
+  async createProjectBranch(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/git/branches`, { rootPath }),
+      request,
+      ProjectGitStatusSchema,
+      options
+    );
+  }
+  async listProjectWorktrees(projectId, rootPath, options = {}) {
+    return this.read(
+      appendQuery(`${projectPath(projectId)}/git/worktrees`, { rootPath }),
+      ProjectGitWorktreePageSchema,
+      options
+    );
+  }
+  async createProjectWorktree(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/git/worktrees`, { rootPath }),
+      request,
+      ProjectWorktreeMutationResponseSchema,
+      options
+    );
+  }
+  async switchProjectWorktree(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/git/worktree`, { rootPath }),
+      request,
+      ProjectWorktreeMutationResponseSchema,
+      options
+    );
+  }
+  async generateCommitMessage(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/git/commit-message`, { rootPath }),
+      request,
+      GenerateCommitMessageResponseSchema,
+      options
+    );
+  }
+  async commitProjectChanges(projectId, rootPath, request, options = {}) {
+    return this.mutation(
+      appendQuery(`${projectPath(projectId)}/git/commits`, { rootPath }),
+      request,
+      CommitProjectChangesResponseSchema,
+      options
+    );
+  }
+  async listProjectFiles(projectId, rootPath, directoryPath, options = {}) {
+    const requestPath = appendQuery(`/v1/projects/${encodeURIComponent(projectId)}/files/tree`, {
+      path: directoryPath ?? void 0,
+      rootPath
+    });
+    return this.read(requestPath, ProjectFileTreeSchema, options);
+  }
+  async searchProjectFiles(projectId, rootPath, query, sessionId, options = {}) {
+    const requestPath = appendQuery(`/v1/projects/${encodeURIComponent(projectId)}/files/search`, {
+      query,
+      rootPath,
+      sessionId
+    });
+    return this.read(requestPath, ProjectFileSearchPageSchema, options);
+  }
+  async stopProjectFileSearch(projectId, rootPath, sessionId, options = {}) {
+    return this.mutation(
+      `/v1/projects/${encodeURIComponent(projectId)}/files/search/stop`,
+      { rootPath, sessionId },
+      StopProjectFileSearchResponseSchema,
+      options
+    );
+  }
+  async readProjectSourceFile(projectId, rootPath, path, cursor, options = {}) {
+    const requestPath = appendQuery(`${projectPath(projectId)}/files/source`, {
+      cursor,
+      path,
+      rootPath
+    });
+    return this.read(requestPath, ProjectSourceFileSchema, options);
+  }
+};
+
+// packages/client/src/http-client-task-archive.ts
+var TaskArchiveHttpClient = class extends ProjectHttpClient {
+  async archiveTask(projectId, taskId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/archive`,
+      {},
+      ArchiveAgentTaskResponseSchema,
+      options
+    );
+  }
+  async unarchiveTask(projectId, taskId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/unarchive`,
+      {},
+      UnarchiveAgentTaskResponseSchema,
+      options
+    );
+  }
+  async deleteTask(projectId, taskId, options = {}) {
+    return this.mutation(
+      taskPath(projectId, taskId),
+      {},
+      DeleteAgentTaskResponseSchema,
+      options,
+      "DELETE"
+    );
+  }
+};
+
+// packages/client/src/http-client-tasks.ts
+var TaskHttpClient = class extends TaskArchiveHttpClient {
+  async listQueuedSubmissions(projectId, taskId, input = {}, options = {}) {
+    return this.read(
+      appendQuery(`${taskPath(projectId, taskId)}/queue`, input),
+      AgentQueuedSubmissionPageSchema,
+      options
+    );
+  }
+  async addQueuedSubmission(projectId, taskId, input, clientUserMessageId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/queue`,
+      { clientUserMessageId, input },
+      AddAgentQueuedSubmissionResponseSchema,
+      options
+    );
+  }
+  async updateQueuedSubmission(projectId, taskId, queuedSubmissionId, input, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/queue/${encodeURIComponent(queuedSubmissionId)}`,
+      { input },
+      UpdateAgentQueuedSubmissionResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async deleteQueuedSubmission(projectId, taskId, queuedSubmissionId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/queue/${encodeURIComponent(queuedSubmissionId)}`,
+      {},
+      DeleteAgentQueuedSubmissionResponseSchema,
+      options,
+      "DELETE"
+    );
+  }
+  async reorderQueuedSubmissions(projectId, taskId, queuedSubmissionIds, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/queue/reorder`,
+      { queuedSubmissionIds },
+      ReorderAgentQueuedSubmissionsResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async startQueuedSubmission(projectId, taskId, queuedSubmissionId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/queue/start`,
+      { ...queuedSubmissionId === void 0 ? {} : { queuedSubmissionId } },
+      StartAgentQueuedSubmissionResponseSchema,
+      options
+    );
+  }
+  async listTasks(projectId, options = {}, requestOptions = {}) {
+    const path = appendQuery(`${projectPath(projectId)}/tasks`, options);
+    return this.read(path, AgentTaskPageSchema, requestOptions);
+  }
+  async readTask(projectId, taskId, options = {}) {
+    const { cursor, ...readOptions } = options;
+    return this.read(
+      appendQuery(taskPath(projectId, taskId), { cursor }),
+      AgentTaskSnapshotResponseSchema,
+      readOptions
+    );
+  }
+  getTaskAttachmentUrl(projectId, taskId, attachmentId) {
+    return buildTaskAttachmentUrl(this.baseUrl, projectId, taskId, attachmentId);
+  }
+  async openTaskAttachment(projectId, taskId, attachmentId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/attachments/${encodeURIComponent(attachmentId)}/open`,
+      {},
+      OpenAgentTaskAttachmentResponseSchema,
+      options
+    );
+  }
+  async listBackgroundTerminals(projectId, taskId, options = {}) {
+    return this.read(
+      `${taskPath(projectId, taskId)}/background-terminals`,
+      AgentBackgroundTerminalPageSchema,
+      options
+    );
+  }
+  async terminateBackgroundTerminal(projectId, taskId, terminalId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/background-terminals/${encodeURIComponent(terminalId)}/terminate`,
+      {},
+      TerminateAgentBackgroundTerminalResponseSchema,
+      options
+    );
+  }
+  async getTaskSettings(projectId, taskId, options = {}) {
+    return this.read(
+      `${taskPath(projectId, taskId)}/settings`,
+      AgentTaskSettingsResponseSchema,
+      options
+    );
+  }
+  async updateTaskSettings(projectId, taskId, settings, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/settings`,
+      settings,
+      AgentTaskSettingsResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async startTask(projectId, options = {}) {
+    return this.mutation(
+      `${projectPath(projectId)}/tasks`,
+      {},
+      StartAgentTaskResponseSchema,
+      options
+    );
+  }
+  async pinTask(projectId, taskId, pinned, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/pin`,
+      { pinned },
+      PinAgentTaskResponseSchema,
+      options,
+      "PUT"
+    );
+  }
+  async renameTask(projectId, taskId, title, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/rename`,
+      { title },
+      RenameAgentTaskResponseSchema,
+      options
+    );
+  }
+  async unsubscribeTask(projectId, taskId) {
+    return this.request(
+      `${taskPath(projectId, taskId)}/unsubscribe`,
+      UnsubscribeAgentTaskResponseSchema,
+      { body: "{}", headers: { "content-type": "application/json" }, method: "POST" }
+    );
+  }
+  async startReview(projectId, taskId, input, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/review`,
+      input,
+      ReviewAgentTaskResponseSchema,
+      options
+    );
+  }
+  async compactTask(projectId, taskId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/compact`,
+      {},
+      CompactAgentTaskResponseSchema,
+      options
+    );
+  }
+  async forkTask(projectId, taskId, input, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/fork`,
+      input,
+      ForkAgentTaskResponseSchema,
+      options
+    );
+  }
+  async uploadFeedback(projectId, taskId, input, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/feedback`,
+      input,
+      UploadAgentFeedbackResponseSchema,
+      options
+    );
+  }
+  async uploadAttachment(projectId, input, options = {}) {
+    const body = new FormData();
+    body.set("attachment", input.content, input.name);
+    return this.request(
+      `${projectPath(projectId)}/attachments/${input.kind}`,
+      AgentAttachmentUploadResponseSchema,
+      {
+        body,
+        headers: {
+          "idempotency-key": options.idempotencyKey ?? v4_default()
+        },
+        method: "POST"
+      },
+      AgentMutationErrorSchema,
+      {
+        ...options.signal === void 0 ? {} : { signal: options.signal },
+        timeoutMs: this.requestTimeouts.mutationMs
+      }
+    );
+  }
+  async importHostAttachment(projectId, kind, path, options = {}) {
+    return this.mutation(
+      `${projectPath(projectId)}/attachments/${kind}/host`,
+      { path },
+      AgentAttachmentUploadResponseSchema,
+      options
+    );
+  }
+  async startTurn(projectId, taskId, input, turnOptions, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/turns`,
+      { input, options: turnOptions },
+      StartAgentTurnResponseSchema,
+      options
+    );
+  }
+  async steerTurn(projectId, taskId, turnId, input, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/turns/${encodeURIComponent(turnId)}/steer`,
+      { input, taskId },
+      SteerAgentTurnResponseSchema,
+      options
+    );
+  }
+  async interruptTurn(projectId, taskId, turnId, options = {}) {
+    return this.mutation(
+      `${taskPath(projectId, taskId)}/turns/${encodeURIComponent(turnId)}/interrupt`,
+      { taskId },
+      InterruptAgentTurnResponseSchema,
+      options
+    );
+  }
+  async resolvePendingRequest(request, resolution, options = {}) {
+    const body = {
+      itemId: request.itemId,
+      projectId: request.projectId,
+      resolution,
+      taskId: request.taskId,
+      turnId: request.turnId,
+      type: request.type
+    };
+    return this.mutation(
+      `${taskPath(request.projectId, request.taskId)}/pending-requests/${encodeURIComponent(request.requestId)}/resolve`,
+      body,
+      ResolvePendingRequestResponseSchema,
+      options
+    );
+  }
+};
+
+// packages/client/src/http-client.ts
+var CodexlyClient = class extends TaskHttpClient {
+};
+
+export { CodexlyClient, CodexlyEventError, CodexlyHttpError, CodexlyMutationError, CodexlyResponseError, buildProjectAttachmentUrl, buildProjectImageFileUrl, buildTaskAttachmentUrl, startAgentEventSubscription };