deploynest 0.0.1

package/README.md

@@ -0,0 +1,75 @@
+# DeployNest API Client
+
+Programmatic, type-safe client for the DeployNest HTTP API. Built on [Hono's typed client](https://hono.dev/docs/guides/rpc) so requests stay in sync with the server route definitions.
+
+## Installation
+
+Inside the DeployNest monorepo, the package is available as a workspace dependency:
+
+```bash
+bun add deploynest
+```
+
+## Quick start
+
+```ts
+import { DeployNestClient } from "deploynest"
+
+const api = new DeployNestClient("https://deploynest.app")
+
+const result = await api.servers.getServers("org_abc123")
+
+if (result.success) {
+  console.log(result.servers)
+} else {
+  console.error(result.message)
+}
+```
+
+When used from the DeployNest web app, pass the current origin so requests stay same-origin and session cookies are sent automatically:
+
+```ts
+const api = new DeployNestClient(window.location.origin, {
+  userAgent: "DeployNest/1.0.0",
+})
+```
+
+## Configuration
+
+```ts
+import { DeployNestClient, type ClientOptions } from "deploynest"
+
+const opts: ClientOptions = {
+  bearerToken: "your-token", // optional Authorization: Bearer header
+  userAgent: "MyApp/1.0.0",  // optional User-Agent header
+}
+
+const api = new DeployNestClient("https://deploynest.app", opts)
+```
+
+| Option        | Description                                                                                                                                      |
+| ------------- | ------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `baseURL`     | Deployment origin (e.g. `https://deploynest.app` or `http://localhost:3000`). Do not include `/api` — resource paths are appended automatically. |
+| `bearerToken` | Sets an `Authorization: Bearer …` header on every request.                                                                                       |
+| `userAgent`   | Sets a custom `User-Agent` header on every request.                                                                                              |
+
+## Response shape
+
+Every method returns a discriminated result. Check `success` before reading the payload:
+
+```ts
+// Success
+{ success: true, servers: [...] }
+{ success: true, credential: {...} }
+
+// Failure
+{ success: false, message: "Forbidden." }
+```
+
+## Authentication
+
+All endpoints require authentication. When the client runs in the browser against the same origin as the app, session cookies are included automatically.
+
+For server-side or external scripts, pass a bearer token via `ClientOptions.bearerToken`.
+
+Every organization-scoped method requires an `organizationId`. The API validates that the authenticated user has the appropriate organization permission before returning data.

package/dist/clients/base.d.ts

@@ -0,0 +1,12 @@
+import type { Hono } from "hono";
+import { hc } from "hono/client";
+export type HonoClient<App extends Hono> = ReturnType<typeof hc<App>>;
+export interface BaseClientOptions {
+    bearerToken?: string;
+    userAgent?: string;
+}
+export declare class BaseClient<HonoApp extends Hono> {
+    readonly baseURL: string;
+    readonly client: HonoClient<HonoApp>;
+    constructor(baseURL: string, basePath: string, opts: BaseClientOptions);
+}

package/dist/clients/base.js

@@ -0,0 +1,35 @@
+// src/utils.ts
+function path(baseURL, path2) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const normalizedPath = path2.replace(/^\/+/, "");
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return `${normalizedBase}/${normalizedPath}`;
+}
+
+// src/clients/base.ts
+import { hc } from "hono/client";
+class BaseClient {
+  baseURL;
+  client;
+  constructor(baseURL, basePath, opts) {
+    let headers = {};
+    if (opts.bearerToken) {
+      headers.Authorization = `Bearer ${opts.bearerToken}`;
+    }
+    if (opts.userAgent) {
+      headers["User-Agent"] = opts.userAgent;
+    }
+    if (Object.keys(headers).length === 0) {
+      headers = undefined;
+    }
+    this.baseURL = path(baseURL, basePath);
+    this.client = hc(this.baseURL, {
+      headers
+    });
+  }
+}
+export {
+  BaseClient
+};

package/dist/clients/credentials.d.ts

@@ -0,0 +1,54 @@
+import { type BaseClientOptions } from "./base";
+export declare class CredentialsClient {
+    private readonly base;
+    constructor(baseURL: string, opts: BaseClientOptions);
+    private get client();
+    getCredentials(organizationId: string): Promise<{
+        success: boolean;
+        credentials: {
+            id: string;
+            name: string;
+            type: "private_key";
+            publicKey: string | null;
+            fingerprint: string | null;
+            createdAt: string;
+        }[];
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        credentials?: undefined;
+    }>;
+    createCredential(organizationId: string, name: string, privateKey: string): Promise<{
+        success: boolean;
+        credential: {
+            id: `${string}-${string}-${string}-${string}-${string}`;
+            name: string;
+            type: string;
+            publicKey: string;
+            fingerprint: string;
+            createdAt: string;
+        };
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        credential?: undefined;
+    }>;
+    generatePrivateKey(): Promise<{
+        success: boolean;
+        privateKey: string;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        privateKey?: undefined;
+    }>;
+    deleteCredential(credentialId: string, organizationId: string): Promise<{
+        success: boolean;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/clients/credentials.js

@@ -0,0 +1,115 @@
+// src/utils.ts
+function path(baseURL, path2) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const normalizedPath = path2.replace(/^\/+/, "");
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return `${normalizedBase}/${normalizedPath}`;
+}
+
+// src/clients/base.ts
+import { hc } from "hono/client";
+class BaseClient {
+  baseURL;
+  client;
+  constructor(baseURL, basePath, opts) {
+    let headers = {};
+    if (opts.bearerToken) {
+      headers.Authorization = `Bearer ${opts.bearerToken}`;
+    }
+    if (opts.userAgent) {
+      headers["User-Agent"] = opts.userAgent;
+    }
+    if (Object.keys(headers).length === 0) {
+      headers = undefined;
+    }
+    this.baseURL = path(baseURL, basePath);
+    this.client = hc(this.baseURL, {
+      headers
+    });
+  }
+}
+
+// src/clients/credentials.ts
+class CredentialsClient {
+  base;
+  constructor(baseURL, opts) {
+    this.base = new BaseClient(baseURL, "/api/credentials", opts);
+  }
+  get client() {
+    return this.base.client;
+  }
+  async getCredentials(organizationId) {
+    const response = await this.client.index.$get({
+      query: {
+        organizationId
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        credentials: data2.credentials
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async createCredential(organizationId, name, privateKey) {
+    const response = await this.client.index.$post({
+      json: {
+        organizationId,
+        name,
+        privateKey
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        credential: data2.credential
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async generatePrivateKey() {
+    const response = await this.client["generate-private-key"].$post();
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        privateKey: data2.privateKey
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async deleteCredential(credentialId, organizationId) {
+    const response = await this.client[":credentialId"].$delete({
+      param: { credentialId },
+      query: { organizationId }
+    });
+    if (response.ok) {
+      return { success: true };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+}
+export {
+  CredentialsClient
+};

package/dist/clients/servers.d.ts

@@ -0,0 +1,60 @@
+import { type BaseClientOptions } from "./base";
+export declare class ServersClient {
+    private readonly base;
+    constructor(baseURL: string, opts: BaseClientOptions);
+    private get client();
+    getServers(organizationId: string): Promise<{
+        success: boolean;
+        servers: {
+            id: string;
+            ip: string;
+            port: number;
+            username: string;
+            setup: boolean;
+            privateKeyCredentialId: string;
+            privateKeyCredentialName: string;
+            createdAt: string;
+        }[];
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        servers?: undefined;
+    }>;
+    createServer(organizationId: string, ip: string, port: number, username: string, privateKeyCredentialId: string): Promise<{
+        success: boolean;
+        server: {
+            id: string;
+            ip: string;
+            port: number;
+            username: string;
+            setup: boolean;
+            privateKeyCredentialId: string;
+            privateKeyCredentialName: string;
+            createdAt: string;
+        };
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+        server?: undefined;
+    }>;
+    setupServer(serverId: string, organizationId: string): Promise<{
+        alreadyInstalled: boolean;
+        dockerVersion: string;
+        log: string[];
+        ok: true;
+        success: boolean;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+    }>;
+    deleteServer(serverId: string, organizationId: string): Promise<{
+        success: boolean;
+        message?: undefined;
+    } | {
+        success: boolean;
+        message: string;
+    }>;
+}

package/dist/clients/servers.js

@@ -0,0 +1,120 @@
+// src/utils.ts
+function path(baseURL, path2) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const normalizedPath = path2.replace(/^\/+/, "");
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return `${normalizedBase}/${normalizedPath}`;
+}
+
+// src/clients/base.ts
+import { hc } from "hono/client";
+class BaseClient {
+  baseURL;
+  client;
+  constructor(baseURL, basePath, opts) {
+    let headers = {};
+    if (opts.bearerToken) {
+      headers.Authorization = `Bearer ${opts.bearerToken}`;
+    }
+    if (opts.userAgent) {
+      headers["User-Agent"] = opts.userAgent;
+    }
+    if (Object.keys(headers).length === 0) {
+      headers = undefined;
+    }
+    this.baseURL = path(baseURL, basePath);
+    this.client = hc(this.baseURL, {
+      headers
+    });
+  }
+}
+
+// src/clients/servers.ts
+class ServersClient {
+  base;
+  constructor(baseURL, opts) {
+    this.base = new BaseClient(baseURL, "/api/servers", opts);
+  }
+  get client() {
+    return this.base.client;
+  }
+  async getServers(organizationId) {
+    const response = await this.client.index.$get({
+      query: {
+        organizationId
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        servers: data2.servers
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async createServer(organizationId, ip, port, username, privateKeyCredentialId) {
+    const response = await this.client.index.$post({
+      json: {
+        organizationId,
+        ip,
+        port,
+        username,
+        privateKeyCredentialId
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        server: data2.server
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async setupServer(serverId, organizationId) {
+    const response = await this.client[":serverId"].setup.$post({
+      param: { serverId },
+      query: { organizationId }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        ...data2
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async deleteServer(serverId, organizationId) {
+    const response = await this.client[":serverId"].$delete({
+      param: { serverId },
+      query: { organizationId }
+    });
+    if (response.ok) {
+      return { success: true };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+}
+export {
+  ServersClient
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { type BaseClientOptions } from "~/clients/base";
+import { CredentialsClient } from "~/clients/credentials";
+import { ServersClient } from "~/clients/servers";
+export type ClientOptions = BaseClientOptions;
+export declare class DeployNestClient {
+    readonly baseURL: string;
+    readonly credentials: CredentialsClient;
+    readonly servers: ServersClient;
+    constructor(baseURL?: string, opts?: ClientOptions);
+}

package/dist/index.js

@@ -0,0 +1,212 @@
+// src/utils.ts
+function path(baseURL, path2) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const normalizedPath = path2.replace(/^\/+/, "");
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return `${normalizedBase}/${normalizedPath}`;
+}
+
+// src/clients/base.ts
+import { hc } from "hono/client";
+class BaseClient {
+  baseURL;
+  client;
+  constructor(baseURL, basePath, opts) {
+    let headers = {};
+    if (opts.bearerToken) {
+      headers.Authorization = `Bearer ${opts.bearerToken}`;
+    }
+    if (opts.userAgent) {
+      headers["User-Agent"] = opts.userAgent;
+    }
+    if (Object.keys(headers).length === 0) {
+      headers = undefined;
+    }
+    this.baseURL = path(baseURL, basePath);
+    this.client = hc(this.baseURL, {
+      headers
+    });
+  }
+}
+
+// src/clients/credentials.ts
+class CredentialsClient {
+  base;
+  constructor(baseURL, opts) {
+    this.base = new BaseClient(baseURL, "/api/credentials", opts);
+  }
+  get client() {
+    return this.base.client;
+  }
+  async getCredentials(organizationId) {
+    const response = await this.client.index.$get({
+      query: {
+        organizationId
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        credentials: data2.credentials
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async createCredential(organizationId, name, privateKey) {
+    const response = await this.client.index.$post({
+      json: {
+        organizationId,
+        name,
+        privateKey
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        credential: data2.credential
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async generatePrivateKey() {
+    const response = await this.client["generate-private-key"].$post();
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        privateKey: data2.privateKey
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async deleteCredential(credentialId, organizationId) {
+    const response = await this.client[":credentialId"].$delete({
+      param: { credentialId },
+      query: { organizationId }
+    });
+    if (response.ok) {
+      return { success: true };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+}
+
+// src/clients/servers.ts
+class ServersClient {
+  base;
+  constructor(baseURL, opts) {
+    this.base = new BaseClient(baseURL, "/api/servers", opts);
+  }
+  get client() {
+    return this.base.client;
+  }
+  async getServers(organizationId) {
+    const response = await this.client.index.$get({
+      query: {
+        organizationId
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        servers: data2.servers
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async createServer(organizationId, ip, port, username, privateKeyCredentialId) {
+    const response = await this.client.index.$post({
+      json: {
+        organizationId,
+        ip,
+        port,
+        username,
+        privateKeyCredentialId
+      }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        server: data2.server
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async setupServer(serverId, organizationId) {
+    const response = await this.client[":serverId"].setup.$post({
+      param: { serverId },
+      query: { organizationId }
+    });
+    if (response.ok) {
+      const data2 = await response.json();
+      return {
+        success: true,
+        ...data2
+      };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+  async deleteServer(serverId, organizationId) {
+    const response = await this.client[":serverId"].$delete({
+      param: { serverId },
+      query: { organizationId }
+    });
+    if (response.ok) {
+      return { success: true };
+    }
+    const data = await response.json();
+    return {
+      success: false,
+      message: data.message
+    };
+  }
+}
+
+// src/index.ts
+class DeployNestClient {
+  baseURL;
+  credentials;
+  servers;
+  constructor(baseURL = "https://deploynest.app/api", opts = {}) {
+    this.baseURL = baseURL;
+    this.credentials = new CredentialsClient(baseURL, opts);
+    this.servers = new ServersClient(baseURL, opts);
+  }
+}
+export {
+  DeployNestClient
+};

package/dist/utils.d.ts

@@ -0,0 +1 @@
+export declare function path(baseURL: string, path: string): string;

package/dist/utils.js

@@ -0,0 +1,12 @@
+// src/utils.ts
+function path(baseURL, path2) {
+  const normalizedBase = baseURL.replace(/\/+$/, "");
+  const normalizedPath = path2.replace(/^\/+/, "");
+  if (!normalizedPath) {
+    return normalizedBase || "/";
+  }
+  return `${normalizedBase}/${normalizedPath}`;
+}
+export {
+  path
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "deploynest",
+  "version": "0.0.1",
+  "main": "./dist/index.js",
+  "devDependencies": {
+    "@types/bun": "1.3.14",
+    "typescript": "6.0.3"
+  },
+  "dependencies": {
+    "hono": "4.12.23"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "description": "Programmatic API client for DeployNest.",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "rm -rf dist && bun run build.ts",
+    "prepack": "bun run build",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "sideEffects": false,
+  "type": "module",
+  "types": "./dist/index.d.ts"
+}