@pickaxe/harnesslayer 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Harnesslayer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# Harnesslayer TypeScript SDK
+
+TypeScript SDK for the Harnesslayer API.
+
+## Install
+
+```bash
+npm install @pickaxe/harnesslayer
+```
+
+## Quick Start
+
+```ts
+import { Harnesslayer } from "@pickaxe/harnesslayer";
+
+const client = new Harnesslayer({ apiKey: "dk-your-api-key" });
+
+const app = await client.app.init("typedef-app", {
+  type: "claude",
+  versionPath: ".claude",
+});
+
+const channel = await app.channel.init("my-api", {
+  type: "api",
+});
+
+for await (const event of channel.run({
+  sessionId: "my-custom-session-id",
+  userId: "stephen@pickaxe.co",
+  input: "hello world",
+})) {
+  if (event.done) break;
+  console.log(event);
+}
+```
+
+## Development
+
+```bash
+npm install
+npm run typecheck
+npm run build
+```

package/dist/index.d.ts

@@ -0,0 +1,578 @@
+type Method = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+type FetchLike = typeof fetch;
+
+interface DriftstoneClientOptions {
+    apiKey: string;
+    version: "v1";
+    timeoutMs: number;
+    fetch?: FetchLike;
+    baseUrl?: string;
+}
+interface DriftstoneRepository {
+    id: string;
+    orgId: string;
+    name: string;
+    slug: string;
+    branch: string;
+}
+interface DriftstoneBranch {
+    id: string;
+    repoId: string;
+    name: string;
+    storagePath: string | null;
+    runId: string | null;
+    status: string | null;
+}
+interface DriftstoneCopy {
+    repoId: string;
+    runId: string;
+    status: string;
+    sourceDir: string | null;
+    destDir: string | null;
+}
+interface DriftstoneCopyStatus {
+    repoId: string;
+    runId: string;
+    status: string;
+    result?: Record<string, unknown> | null;
+}
+interface DriftstoneUpload {
+    repoId: string;
+    uploadId: string;
+    uploadUrls: Array<{
+        name: string;
+        url: string;
+    }>;
+}
+interface UploadFilePayload {
+    name: string;
+    hash: string;
+}
+declare class DriftstoneClient {
+    readonly repos: DriftstoneRepositories;
+    private readonly baseUrl;
+    private readonly headers;
+    private readonly timeoutMs;
+    private readonly fetchImpl;
+    constructor(options: DriftstoneClientOptions);
+    request<T extends Record<string, unknown> = Record<string, unknown>>(method: Method, requestPath: string, payload?: Record<string, unknown>): Promise<T>;
+    uploadFile(url: string, filePath: string): Promise<boolean>;
+    uploadFiles(upload: DriftstoneUpload, files: UploadFilePayload[], root: string): Promise<boolean>;
+    private parseResponse;
+}
+declare class DriftstoneRepositories {
+    private readonly client;
+    constructor(client: DriftstoneClient);
+    create(name: string): Promise<DriftstoneRepository>;
+    get(repo: string): Promise<DriftstoneRepository>;
+    createBranch(repo: string, name: string, options: {
+        storageDir: string;
+        message?: string;
+        transforms?: Record<string, unknown>;
+        archive?: boolean;
+    }): Promise<DriftstoneBranch>;
+    createUpload(repo: string, options: {
+        files: UploadFilePayload[];
+        storageDir: string;
+        branch?: string;
+    }): Promise<DriftstoneUpload>;
+    completeUpload(repo: string, uploadId: string): Promise<boolean>;
+    copyDirectory(repo: string, options: {
+        sourceDir: string;
+        destDir: string;
+        sourceBranch?: string;
+        destBranch?: string;
+        transforms?: Record<string, unknown>;
+        archive?: boolean;
+    }): Promise<DriftstoneCopy>;
+    getCopyStatus(repo: string, runId: string): Promise<DriftstoneCopyStatus>;
+}
+
+declare class ResourceBase {
+    protected readonly client: Harnesslayer;
+    protected readonly driftstone: DriftstoneClient;
+    constructor(client: Harnesslayer);
+}
+declare class AppBase extends ResourceBase {
+    protected readonly appId: string;
+    constructor(client: Harnesslayer, appId: string);
+}
+declare class ProfileBase extends AppBase {
+    protected readonly profileId: string;
+    constructor(client: Harnesslayer, appId: string, profileId: string);
+}
+
+declare class HarnesslayerAccessGroup extends AppBase {
+    create(name: string, limit: number, options?: {
+        limitReset: AccessGroupLimitReset;
+        limitMessage?: string;
+    }): Promise<HarnesslayerAccessGroupModel>;
+    retrieve(accessGroupId: string): Promise<HarnesslayerAccessGroupModel | null>;
+    update(accessGroupId: string, options: {
+        name?: string;
+        limit?: number;
+        limitReset?: AccessGroupLimitReset;
+        limitMessage?: string;
+    }): Promise<HarnesslayerAccessGroupModel>;
+    list(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<HarnesslayerAccessGroupModel[]>;
+    delete(accessGroupId: string): Promise<boolean>;
+}
+
+declare class HarnesslayerChannel extends AppBase {
+    init(slug: string, options: {
+        type: "api";
+        name?: string;
+        webhook?: ChannelAPIWebhook;
+        data?: never;
+    } | {
+        type: "imessage";
+        name?: string;
+        webhook?: never;
+        data: ChannelIMessageData;
+    }): Promise<HarnesslayerChannelModel>;
+    run(channelId: string, options: ChannelRunOptions): AsyncIterable<ResponseRunStreamEvent>;
+    private validateWebhook;
+    private validateIMessageData;
+}
+
+declare class HarnesslayerConflict extends AppBase {
+    retrieve(conflictId: string): Promise<HarnesslayerConflictModel | null>;
+    list(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<HarnesslayerConflictModel[]>;
+}
+
+declare class HarnesslayerInstance extends AppBase {
+    retrieve(instanceId: string): Promise<HarnesslayerInstanceModel | null>;
+    list(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<HarnesslayerInstanceModel[]>;
+}
+
+declare class HarnesslayerState extends ProfileBase {
+    create(options: {
+        stateId?: string;
+        statePath?: string;
+    }): Promise<boolean>;
+    download(outPath: string, stateId?: string): Promise<boolean>;
+    clone(options?: {
+        stateId?: string;
+        transform?: CloneTransform;
+    }): Promise<boolean>;
+    waitForCopyRun(runId: string | null | undefined, operation: string): Promise<{
+        status: string;
+        result?: Record<string, unknown> | null;
+    } | null>;
+    private resolveStateId;
+    private tryResolveStateId;
+}
+
+declare class HarnesslayerProfile extends AppBase {
+    init(identifier: string, options?: {
+        statePath?: string;
+        accessGroupId?: string;
+        metadata?: JsonObject;
+    }): Promise<HarnesslayerProfileModel>;
+    retrieve(profileId: string): Promise<HarnesslayerProfileModel | null>;
+    update(profileId: string, options: {
+        identifier?: string;
+        accessGroupId?: string;
+        metadata?: JsonObject;
+    }): Promise<HarnesslayerProfileModel>;
+    state(profileId: string): HarnesslayerState;
+    delete(profileId: string): Promise<boolean>;
+}
+
+declare class HarnesslayerSession extends AppBase {
+    create(type: ChannelType): Promise<HarnesslayerSessionModel>;
+    retrieve(sessionId: string): Promise<HarnesslayerSessionModel | null>;
+    update(sessionId: string, options: {
+        type?: SessionType;
+        userIds?: string[];
+    }): Promise<HarnesslayerSessionModel>;
+    list(options?: {
+        page?: number;
+        pageSize?: number;
+    }): Promise<HarnesslayerSessionModel[]>;
+    delete(sessionId: string): Promise<boolean>;
+}
+
+declare class HarnesslayerVersion extends AppBase {
+    create(options: {
+        versionId?: string;
+        versionPath?: string;
+    }): Promise<boolean>;
+    download(outPath: string, versionId?: string): Promise<boolean>;
+    clone(options?: {
+        versionId?: string;
+        transform?: CloneTransform;
+    }): Promise<boolean>;
+    sync(strategy?: SyncStrategy): Promise<boolean>;
+    private resolveVersionId;
+}
+
+type ApiVersion = "v1";
+type JsonObject = Record<string, unknown>;
+type ApplicationType = "claude" | "openclaw";
+type ChannelType = "api" | "imessage";
+type SessionType = "single" | "multiple";
+type AccessGroupLimitReset = "daily" | "monthly" | "yearly";
+type SyncStrategy = "manual" | "current" | "incoming" | "smart";
+type SyncStatus = "in_progress" | "complete" | "failed" | "conflict";
+type InstanceStatus = "running" | "terminated";
+type ConflictReason = "missing_head_state" | "missing_state_branch" | "merge_conflict";
+type MessageType = "user" | "assistant";
+type WebhookEvent = "profile.created";
+type WebhookMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface AppInitLimit {
+    name?: string | null;
+    amount: number;
+    interval: "daily" | "weekly" | "monthly";
+    message?: string | null;
+}
+type AppInitCredentialMCPOAuthNoneParam = {
+    type: "none";
+};
+type AppInitCredentialMCPOAuthBasicParam = {
+    type: "client_secret_basic";
+    client_secret: string;
+};
+type AppInitCredentialMCPOAuthPostParam = {
+    type: "client_secret_post";
+    client_secret: string;
+};
+interface AppInitCredentialMCPOAuthRefresh {
+    client_id: string;
+    refresh_token: string;
+    token_endpoint: string;
+    token_endpoint_auth: AppInitCredentialMCPOAuthNoneParam | AppInitCredentialMCPOAuthBasicParam | AppInitCredentialMCPOAuthPostParam;
+    resource?: string | null;
+    scope?: string | null;
+}
+interface AppInitCredentialMCPOAuth {
+    access_token: string;
+    mcp_server_url: string;
+    type: "mcp_oauth";
+    expires_at?: Date | string | null;
+    refresh?: AppInitCredentialMCPOAuthRefresh | null;
+}
+interface AppInitCredentialMCPStaticBearer {
+    token: string;
+    mcp_server_url: string;
+    type: "mcp_oauth" | "mcp_static_bearer";
+}
+type AppInitCredential = AppInitCredentialMCPOAuth | AppInitCredentialMCPStaticBearer;
+interface ChannelAPIWebhook {
+    name: string;
+    url: string;
+    headers?: Record<string, string> | null;
+}
+interface ChannelIMessageData {
+    sendBlueAPIKey: string;
+    sendBlueSecretKey: string;
+    fromNumber: string;
+}
+interface ResponseRunStreamEvent {
+    instanceId: string;
+    index: number;
+    data: unknown;
+    done?: boolean;
+    error?: string | null;
+}
+interface HarnesslayerAppModel {
+    id: string;
+    orgId: string;
+    type: ApplicationType;
+    name: string;
+    slug: string;
+    vaultId: string | null;
+    defaultAccessGroupId: string | null;
+    headVersionId: string | null;
+    metadata: JsonObject | null;
+    createdAt: Date;
+    updatedAt: Date;
+    version: HarnesslayerVersion;
+    channel: HarnesslayerChannel;
+    session: HarnesslayerSession;
+    accessGroup: HarnesslayerAccessGroup;
+    access_group: HarnesslayerAccessGroup;
+    profile: HarnesslayerProfile;
+    instance: HarnesslayerInstance;
+    conflict: HarnesslayerConflict;
+}
+interface HarnesslayerChannelModel {
+    id: string;
+    appId: string;
+    type: ChannelType;
+    slug: string;
+    name: string;
+    webhook: ChannelAPIWebhook | null;
+    data: ChannelIMessageData | null;
+    createdAt: Date;
+    updatedAt: Date;
+    run(options: ChannelRunOptions): AsyncIterable<ResponseRunStreamEvent>;
+}
+interface HarnesslayerAccessGroupModel {
+    id: string;
+    appId: string;
+    name: string;
+    limit: number;
+    limitReset: AccessGroupLimitReset;
+    limitMessage: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerOrganizationModel {
+    id: string;
+    name: string;
+    slug: string;
+    createdBy: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerProfileModel {
+    id: string;
+    appId: string;
+    identifier: string;
+    currentSpending: number;
+    totalSpending: number;
+    metadata: JsonObject | null;
+    headStateId: string | null;
+    initialChannelId: string | null;
+    accessGroupId: string | null;
+    lastResetAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+    state: HarnesslayerState;
+}
+interface HarnesslayerSessionModel {
+    id: string;
+    appId: string;
+    type: SessionType;
+    userIds: string[];
+    profileIds: string[];
+    metadata: JsonObject | null;
+    externalId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerInstanceModel {
+    id: string;
+    appId: string;
+    versionId: string;
+    channelId: string;
+    sessionId: string;
+    profileId: string;
+    accessGroupId: string;
+    stateId: string | null;
+    identifier: string;
+    timeout: number;
+    totalCost: number;
+    costBreakdown: Record<string, number>;
+    tokenBreakdown: Record<string, number>;
+    metadata: JsonObject | null;
+    status: InstanceStatus;
+    error: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerConflictModel {
+    id: string;
+    appId: string;
+    syncId: string;
+    profileId: string;
+    versionId: string;
+    stateId: string;
+    stateBranch: string;
+    reason: ConflictReason;
+    error: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerMessageModel {
+    id: string;
+    appId: string;
+    sessionId: string;
+    historyId: string | null;
+    type: MessageType;
+    parts: JsonObject[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerHistoryModel {
+    id: string;
+    appId: string;
+    sessionId: string;
+    profileId: string;
+    identifier: string;
+    timestamp: number;
+    messages: HarnesslayerMessageModel[];
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerStateModel {
+    id: string;
+    appId: string;
+    profileId: string;
+    version: number;
+    baseVersionId: string | null;
+    baseStateId: string | null;
+    storageUrl: string;
+    downloadUrl: string;
+    map: Record<string, HashMapItem> | null;
+    metadata: JsonObject | null;
+    status: string | null;
+    snapshotStorageUrl: string | null;
+    sandboxId: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerVersionModel {
+    id: string;
+    appId: string;
+    version: number;
+    storageUrl: string;
+    downloadUrl: string;
+    map: Record<string, HashMapItem> | null;
+    metadata: JsonObject | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerSyncModel {
+    id: string;
+    appId: string;
+    versionId: string;
+    status: SyncStatus;
+    dispatchingChunks: boolean;
+    totalChunks: number;
+    pendingChunks: number;
+    failedChunks: number;
+    profilesExpected: number;
+    profilesTotal: number;
+    profilesMerged: number;
+    profilesSkipped: number;
+    profilesConflicted: number;
+    error: string | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HarnesslayerWebhookModel {
+    id: string;
+    appId: string;
+    event: WebhookEvent;
+    method: WebhookMethod;
+    url: string;
+    runCount: number;
+    headers: Record<string, string> | null;
+    lastTriggeredAt: Date | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface HashMapItem {
+    id: string;
+    hash: string;
+}
+interface ChannelRunOptions {
+    userId: string;
+    sessionId?: string | null;
+    input?: string;
+    images?: JsonObject[];
+}
+type CloneTransformValue = JsonObject | string;
+type CloneTransform = Record<string, CloneTransformValue>;
+
+declare class HarnesslayerApp extends ResourceBase {
+    init(slug: string, options: {
+        type: ApplicationType;
+        versionPath: string;
+        name?: string;
+        limit?: AppInitLimit;
+        credentials?: AppInitCredential[];
+    }): Promise<HarnesslayerAppModel>;
+    retrieve(options: {
+        appId?: string;
+        slug?: string;
+    }): Promise<HarnesslayerAppModel | null>;
+    delete(appId: string): Promise<boolean>;
+    channel(appId: string): HarnesslayerChannel;
+    instance(appId: string): HarnesslayerInstance;
+    accessGroup(appId: string): HarnesslayerAccessGroup;
+    profile(appId: string): HarnesslayerProfile;
+    conflict(appId: string): HarnesslayerConflict;
+    private buildAppModel;
+}
+
+declare class HarnesslayerOrganization extends ResourceBase {
+    create(name: string, options: {
+        slug: string;
+    }): Promise<HarnesslayerOrganizationModel>;
+    init(name: string, options: {
+        slug: string;
+        returnIfExist?: boolean;
+        return_if_exist?: boolean;
+    }): Promise<HarnesslayerOrganizationModel>;
+    update(organizationId: string, options: {
+        name?: string;
+        slug?: string;
+    }): Promise<HarnesslayerOrganizationModel>;
+}
+
+declare class HarnesslayerResponse extends ResourceBase {
+    stop(instanceId: string): Promise<Record<string, unknown>>;
+}
+
+interface HarnesslayerOptions {
+    apiKey: string;
+    version?: ApiVersion;
+    timeoutMs?: number;
+    timeout?: number;
+    fetch?: FetchLike;
+    baseUrl?: string;
+    driftstoneBaseUrl?: string;
+}
+declare class Harnesslayer {
+    readonly apiKey: string;
+    readonly apiVersion: ApiVersion;
+    readonly timeoutMs: number;
+    readonly baseUrl: string;
+    readonly driftstone: DriftstoneClient;
+    private readonly transport;
+    constructor(options: HarnesslayerOptions);
+    constructor(apiKey: string, options?: Omit<HarnesslayerOptions, "apiKey">);
+    request<T extends Record<string, unknown> = Record<string, unknown>>(method: Method, path: string, payload?: Record<string, unknown>): Promise<T>;
+    get app(): HarnesslayerApp;
+    get organization(): HarnesslayerOrganization;
+    get response(): HarnesslayerResponse;
+}
+
+declare class HarnesslayerError extends Error {
+    name: string;
+}
+declare class HarnesslayerHTTPError extends HarnesslayerError {
+    name: string;
+}
+declare class HarnesslayerResponseError extends HarnesslayerError {
+    name: string;
+}
+declare class HarnesslayerAPIError extends HarnesslayerError {
+    name: string;
+}
+declare class DriftstoneError extends Error {
+    name: string;
+}
+declare class DriftstoneHTTPError extends DriftstoneError {
+    name: string;
+}
+declare class DriftstoneResponseError extends DriftstoneError {
+    name: string;
+}
+declare class DriftstoneAPIError extends DriftstoneError {
+    name: string;
+}
+
+export { type AccessGroupLimitReset, type ApiVersion, type AppInitCredential, type AppInitCredentialMCPOAuth, type AppInitCredentialMCPOAuthBasicParam, type AppInitCredentialMCPOAuthNoneParam, type AppInitCredentialMCPOAuthPostParam, type AppInitCredentialMCPOAuthRefresh, type AppInitCredentialMCPStaticBearer, type AppInitLimit, type ApplicationType, type ChannelAPIWebhook, type ChannelIMessageData, type ChannelRunOptions, type ChannelType, type CloneTransform, type CloneTransformValue, type ConflictReason, DriftstoneAPIError, DriftstoneError, DriftstoneHTTPError, DriftstoneResponseError, Harnesslayer, HarnesslayerAPIError, HarnesslayerAccessGroup, type HarnesslayerAccessGroupModel, HarnesslayerApp, type HarnesslayerAppModel, HarnesslayerChannel, type HarnesslayerChannelModel, HarnesslayerConflict, type HarnesslayerConflictModel, HarnesslayerError, HarnesslayerHTTPError, type HarnesslayerHistoryModel, HarnesslayerInstance, type HarnesslayerInstanceModel, type HarnesslayerMessageModel, type HarnesslayerOptions, HarnesslayerOrganization, type HarnesslayerOrganizationModel, HarnesslayerProfile, type HarnesslayerProfileModel, HarnesslayerResponse, HarnesslayerResponseError, HarnesslayerSession, type HarnesslayerSessionModel, HarnesslayerState, type HarnesslayerStateModel, type HarnesslayerSyncModel, HarnesslayerVersion, type HarnesslayerVersionModel, type HarnesslayerWebhookModel, type HashMapItem, type InstanceStatus, type JsonObject, type MessageType, type ResponseRunStreamEvent, type SessionType, type SyncStatus, type SyncStrategy, type WebhookEvent, type WebhookMethod, Harnesslayer as default };