@ricsam/r5d-api 0.0.1 → 0.0.3

package/README.md

@@ -1,45 +1,68 @@
 # @ricsam/r5d-api
 
-## ⚠️ IMPORTANT NOTICE ⚠️
-
-**This package is created solely for the purpose of setting up OIDC (OpenID Connect) trusted publishing with npm.**
-
-This is **NOT** a functional package and contains **NO** code or functionality beyond the OIDC setup configuration.
-
-## Purpose
-
-This package exists to:
-1. Configure OIDC trusted publishing for the package name `@ricsam/r5d-api`
-2. Enable secure, token-less publishing from CI/CD workflows
-3. Establish provenance for packages published under this name
-
-## What is OIDC Trusted Publishing?
-
-OIDC trusted publishing allows package maintainers to publish packages directly from their CI/CD workflows without needing to manage npm access tokens. Instead, it uses OpenID Connect to establish trust between the CI/CD provider (like GitHub Actions) and npm.
-
-## Setup Instructions
-
-To properly configure OIDC trusted publishing for this package:
-
-1. Go to [npmjs.com](https://www.npmjs.com/) and navigate to your package settings
-2. Configure the trusted publisher (e.g., GitHub Actions)
-3. Specify the repository and workflow that should be allowed to publish
-4. Use the configured workflow to publish your actual package
-
-## DO NOT USE THIS PACKAGE
-
-This package is a placeholder for OIDC configuration only. It:
-- Contains no executable code
-- Provides no functionality
-- Should not be installed as a dependency
-- Exists only for administrative purposes
-
-## More Information
-
-For more details about npm's trusted publishing feature, see:
-- [npm Trusted Publishing Documentation](https://docs.npmjs.com/generating-provenance-statements)
-- [GitHub Actions OIDC Documentation](https://docs.github.com/en/actions/deployment/security-hardening-your-deployments/about-security-hardening-with-openid-connect)
-
----
-
-**Maintained for OIDC setup purposes only**
+Typed Node.js API client for the r5d.dev CLI backend surface.
+
+## Installation
+
+```bash
+npm install @ricsam/r5d-api
+```
+
+## Usage
+
+```ts
+import { BinctlClient } from "@ricsam/r5d-api";
+
+const client = new BinctlClient({
+  baseUrl: "https://r5d.dev",
+  token: process.env.BINCTL_TOKEN,
+  // or apiKey: process.env.BINCTL_API_KEY
+});
+
+const projects = await client.projects.list();
+console.log(projects);
+```
+
+## Auth
+
+`BinctlClient` supports:
+- interactive token (`bin_tok_*`)
+- API key (`bin_key_*`)
+
+Set either `token` or `apiKey` in client options, or later via:
+- `client.setToken(...)`
+- `client.setApiKey(...)`
+
+Trusted server-side callers that authenticate through custom headers, such as a session cookie, can pass `headers` with `authMode: "headers"`.
+
+## Main API Surface
+
+- `auth.loginStart()`
+- `auth.loginPoll(requestId, { pollCode })`
+- `auth.status()`
+- `auth.logout()`
+- `auth.apiKeys.create/list/revoke`
+- `projects.list()`
+- `projects.create({ name?, orgId? })`
+- `projects.describe(projectRef)`
+- `projects.update(projectRef, { name?, mode? })`
+- `projects.delete(projectRef)`
+- `projects.branches.list/describe(projectRef, ...)`
+- `projects.sessions.list(projectRef, { branch? })`
+- `projects.sessions.create(projectRef, { branchName, name? })`
+- `sessions.describe(sessionId)`
+- `sessions.update(sessionId, { name })`
+- `sessions.delete(sessionId)`
+- `sessions.conversation(sessionId)`
+- `sessions.prompt(sessionId, { message, mode, model })`
+- `sessions.answerQuestions(sessionId, { answers })`
+- `sessions.applyRequiredEnvs(sessionId, { envs })`
+
+## Errors
+
+Non-2xx responses throw `BinctlApiError` with:
+- `status`
+- `path`
+- `body`
+
+Project responses expose `mode: "greenfield" | "prod"`, derived from the database-backed `projects.backwardsCompatible` flag.

package/dist/cjs/index.cjs

@@ -0,0 +1,257 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var index_exports = {};
+__export(index_exports, {
+  BinctlApiError: () => BinctlApiError,
+  BinctlClient: () => BinctlClient
+});
+module.exports = __toCommonJS(index_exports);
+class BinctlApiError extends Error {
+  status;
+  path;
+  body;
+  constructor(message, input) {
+    super(message);
+    this.name = "BinctlApiError";
+    this.status = input.status;
+    this.path = input.path;
+    this.body = input.body;
+  }
+}
+function normalizeBaseUrl(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function withQuery(path, query) {
+  if (!query) {
+    return path;
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) continue;
+    params.set(key, value);
+  }
+  const queryString = params.toString();
+  return queryString.length > 0 ? `${path}?${queryString}` : path;
+}
+class BinctlClient {
+  fetchImpl;
+  baseUrl;
+  token;
+  apiKey;
+  extraHeaders;
+  authMode;
+  constructor(options = {}) {
+    this.fetchImpl = options.fetch ?? fetch;
+    this.baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://r5d.dev");
+    this.token = options.token;
+    this.apiKey = options.apiKey;
+    this.extraHeaders = options.headers ?? {};
+    this.authMode = options.authMode ?? "bearer";
+  }
+  setBaseUrl(baseUrl) {
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  resolveBearerToken() {
+    return this.token ?? this.apiKey;
+  }
+  async request(input) {
+    const authMode = input.auth ?? "auto";
+    const bearerToken = this.resolveBearerToken();
+    const headers = {
+      ...this.extraHeaders,
+      Accept: "application/json"
+    };
+    if (authMode === "auto") {
+      if (!bearerToken) {
+        if (this.authMode !== "headers") {
+          throw new BinctlApiError("Authentication required. Set token or apiKey in BinctlClient.", {
+            status: 401,
+            path: input.path,
+            body: { error: "Missing credentials" }
+          });
+        }
+      } else {
+        headers.Authorization = `Bearer ${bearerToken}`;
+      }
+    }
+    const hasBody = input.body !== void 0;
+    if (hasBody) {
+      headers["Content-Type"] = "application/json";
+    }
+    const pathWithQuery = withQuery(input.path, input.query);
+    const response = await this.fetchImpl(`${this.baseUrl}${pathWithQuery}`, {
+      method: input.method,
+      headers,
+      body: hasBody ? JSON.stringify(input.body) : void 0
+    });
+    const text = await response.text();
+    const payload = text.length > 0 ? safeJsonParse(text) : null;
+    if (!response.ok) {
+      const message = typeof payload === "object" && payload && "error" in payload && typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+      throw new BinctlApiError(message, {
+        status: response.status,
+        path: pathWithQuery,
+        body: payload
+      });
+    }
+    return payload;
+  }
+  auth = {
+    loginStart: (input) => this.request({
+      method: "POST",
+      path: "/api/binctl/auth/login/start",
+      auth: "none",
+      body: {
+        baseUrl: input?.baseUrl
+      }
+    }),
+    loginPoll: (requestId, input) => this.request({
+      method: "GET",
+      path: `/api/binctl/auth/login/poll/${encodeURIComponent(requestId)}`,
+      auth: "none",
+      query: {
+        pollCode: input.pollCode
+      }
+    }),
+    logout: () => this.request({
+      method: "POST",
+      path: "/api/binctl/auth/logout",
+      body: {}
+    }),
+    status: () => this.request({
+      method: "GET",
+      path: "/api/binctl/auth/status"
+    }),
+    apiKeys: {
+      create: (input) => this.request({
+        method: "POST",
+        path: "/api/binctl/auth/api-keys",
+        body: input
+      }),
+      list: () => this.request({
+        method: "GET",
+        path: "/api/binctl/auth/api-keys"
+      }),
+      revoke: (keyId) => this.request({
+        method: "DELETE",
+        path: `/api/binctl/auth/api-keys/${encodeURIComponent(keyId)}`
+      })
+    }
+  };
+  projects = {
+    list: () => this.request({
+      method: "GET",
+      path: "/api/binctl/projects"
+    }),
+    create: (input = {}) => this.request({
+      method: "POST",
+      path: "/api/binctl/projects",
+      body: input
+    }),
+    describe: (projectRef) => this.request({
+      method: "GET",
+      path: `/api/binctl/projects/${encodeURIComponent(projectRef)}`
+    }),
+    update: (projectRef, input) => this.request({
+      method: "PUT",
+      path: `/api/binctl/projects/${encodeURIComponent(projectRef)}`,
+      body: input
+    }),
+    delete: (projectRef) => this.request({
+      method: "DELETE",
+      path: `/api/binctl/projects/${encodeURIComponent(projectRef)}`
+    }),
+    branches: {
+      list: (projectRef) => this.request({
+        method: "GET",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/branches`
+      }),
+      describe: (projectRef, branch) => this.request({
+        method: "GET",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/branches/${encodeURIComponent(branch)}`
+      })
+    },
+    sessions: {
+      list: (projectRef, input) => this.request({
+        method: "GET",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/sessions`,
+        query: {
+          branch: input?.branch
+        }
+      }),
+      create: (projectRef, input) => this.request({
+        method: "POST",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/sessions`,
+        body: input
+      })
+    }
+  };
+  sessions = {
+    describe: (sessionId) => this.request({
+      method: "GET",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}`
+    }),
+    update: (sessionId, input) => this.request({
+      method: "PUT",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}`,
+      body: input
+    }),
+    delete: (sessionId) => this.request({
+      method: "DELETE",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}`
+    }),
+    conversation: (sessionId) => this.request({
+      method: "GET",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/conversation`
+    }),
+    prompt: (sessionId, input) => this.request({
+      method: "POST",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/prompt`,
+      body: input
+    }),
+    answerQuestions: (sessionId, input) => this.request({
+      method: "POST",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/answer-questions`,
+      body: input
+    }),
+    applyRequiredEnvs: (sessionId, input) => this.request({
+      method: "POST",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/apply-required-envs`,
+      body: input
+    })
+  };
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BinctlApiError,
+  BinctlClient
+});

package/dist/cjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/r5d-api",
+  "version": "0.0.3",
+  "type": "commonjs"
+}

package/dist/mjs/index.mjs

@@ -0,0 +1,232 @@
+class BinctlApiError extends Error {
+  status;
+  path;
+  body;
+  constructor(message, input) {
+    super(message);
+    this.name = "BinctlApiError";
+    this.status = input.status;
+    this.path = input.path;
+    this.body = input.body;
+  }
+}
+function normalizeBaseUrl(url) {
+  return url.endsWith("/") ? url.slice(0, -1) : url;
+}
+function withQuery(path, query) {
+  if (!query) {
+    return path;
+  }
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value === void 0) continue;
+    params.set(key, value);
+  }
+  const queryString = params.toString();
+  return queryString.length > 0 ? `${path}?${queryString}` : path;
+}
+class BinctlClient {
+  fetchImpl;
+  baseUrl;
+  token;
+  apiKey;
+  extraHeaders;
+  authMode;
+  constructor(options = {}) {
+    this.fetchImpl = options.fetch ?? fetch;
+    this.baseUrl = normalizeBaseUrl(options.baseUrl ?? "https://r5d.dev");
+    this.token = options.token;
+    this.apiKey = options.apiKey;
+    this.extraHeaders = options.headers ?? {};
+    this.authMode = options.authMode ?? "bearer";
+  }
+  setBaseUrl(baseUrl) {
+    this.baseUrl = normalizeBaseUrl(baseUrl);
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  setApiKey(apiKey) {
+    this.apiKey = apiKey;
+  }
+  resolveBearerToken() {
+    return this.token ?? this.apiKey;
+  }
+  async request(input) {
+    const authMode = input.auth ?? "auto";
+    const bearerToken = this.resolveBearerToken();
+    const headers = {
+      ...this.extraHeaders,
+      Accept: "application/json"
+    };
+    if (authMode === "auto") {
+      if (!bearerToken) {
+        if (this.authMode !== "headers") {
+          throw new BinctlApiError("Authentication required. Set token or apiKey in BinctlClient.", {
+            status: 401,
+            path: input.path,
+            body: { error: "Missing credentials" }
+          });
+        }
+      } else {
+        headers.Authorization = `Bearer ${bearerToken}`;
+      }
+    }
+    const hasBody = input.body !== void 0;
+    if (hasBody) {
+      headers["Content-Type"] = "application/json";
+    }
+    const pathWithQuery = withQuery(input.path, input.query);
+    const response = await this.fetchImpl(`${this.baseUrl}${pathWithQuery}`, {
+      method: input.method,
+      headers,
+      body: hasBody ? JSON.stringify(input.body) : void 0
+    });
+    const text = await response.text();
+    const payload = text.length > 0 ? safeJsonParse(text) : null;
+    if (!response.ok) {
+      const message = typeof payload === "object" && payload && "error" in payload && typeof payload.error === "string" ? payload.error : `Request failed (${response.status})`;
+      throw new BinctlApiError(message, {
+        status: response.status,
+        path: pathWithQuery,
+        body: payload
+      });
+    }
+    return payload;
+  }
+  auth = {
+    loginStart: (input) => this.request({
+      method: "POST",
+      path: "/api/binctl/auth/login/start",
+      auth: "none",
+      body: {
+        baseUrl: input?.baseUrl
+      }
+    }),
+    loginPoll: (requestId, input) => this.request({
+      method: "GET",
+      path: `/api/binctl/auth/login/poll/${encodeURIComponent(requestId)}`,
+      auth: "none",
+      query: {
+        pollCode: input.pollCode
+      }
+    }),
+    logout: () => this.request({
+      method: "POST",
+      path: "/api/binctl/auth/logout",
+      body: {}
+    }),
+    status: () => this.request({
+      method: "GET",
+      path: "/api/binctl/auth/status"
+    }),
+    apiKeys: {
+      create: (input) => this.request({
+        method: "POST",
+        path: "/api/binctl/auth/api-keys",
+        body: input
+      }),
+      list: () => this.request({
+        method: "GET",
+        path: "/api/binctl/auth/api-keys"
+      }),
+      revoke: (keyId) => this.request({
+        method: "DELETE",
+        path: `/api/binctl/auth/api-keys/${encodeURIComponent(keyId)}`
+      })
+    }
+  };
+  projects = {
+    list: () => this.request({
+      method: "GET",
+      path: "/api/binctl/projects"
+    }),
+    create: (input = {}) => this.request({
+      method: "POST",
+      path: "/api/binctl/projects",
+      body: input
+    }),
+    describe: (projectRef) => this.request({
+      method: "GET",
+      path: `/api/binctl/projects/${encodeURIComponent(projectRef)}`
+    }),
+    update: (projectRef, input) => this.request({
+      method: "PUT",
+      path: `/api/binctl/projects/${encodeURIComponent(projectRef)}`,
+      body: input
+    }),
+    delete: (projectRef) => this.request({
+      method: "DELETE",
+      path: `/api/binctl/projects/${encodeURIComponent(projectRef)}`
+    }),
+    branches: {
+      list: (projectRef) => this.request({
+        method: "GET",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/branches`
+      }),
+      describe: (projectRef, branch) => this.request({
+        method: "GET",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/branches/${encodeURIComponent(branch)}`
+      })
+    },
+    sessions: {
+      list: (projectRef, input) => this.request({
+        method: "GET",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/sessions`,
+        query: {
+          branch: input?.branch
+        }
+      }),
+      create: (projectRef, input) => this.request({
+        method: "POST",
+        path: `/api/binctl/projects/${encodeURIComponent(projectRef)}/sessions`,
+        body: input
+      })
+    }
+  };
+  sessions = {
+    describe: (sessionId) => this.request({
+      method: "GET",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}`
+    }),
+    update: (sessionId, input) => this.request({
+      method: "PUT",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}`,
+      body: input
+    }),
+    delete: (sessionId) => this.request({
+      method: "DELETE",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}`
+    }),
+    conversation: (sessionId) => this.request({
+      method: "GET",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/conversation`
+    }),
+    prompt: (sessionId, input) => this.request({
+      method: "POST",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/prompt`,
+      body: input
+    }),
+    answerQuestions: (sessionId, input) => this.request({
+      method: "POST",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/answer-questions`,
+      body: input
+    }),
+    applyRequiredEnvs: (sessionId, input) => this.request({
+      method: "POST",
+      path: `/api/binctl/sessions/${encodeURIComponent(sessionId)}/apply-required-envs`,
+      body: input
+    })
+  };
+}
+function safeJsonParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return { raw: text };
+  }
+}
+export {
+  BinctlApiError,
+  BinctlClient
+};

package/dist/mjs/package.json

@@ -0,0 +1,5 @@
+{
+  "name": "@ricsam/r5d-api",
+  "version": "0.0.3",
+  "type": "module"
+}

package/dist/types/index.d.ts

@@ -0,0 +1,211 @@
+export type ChatMode = "ask" | "plan" | "build" | "agent" | "explore" | "review" | "test" | "research";
+export type ModelTier = "low" | "medium" | "high" | "max";
+export type BinctlProject = {
+    id: string;
+    slug: string | null;
+    name: string | null;
+    mode: "greenfield" | "prod";
+    createdAt: string;
+    updatedAt: string;
+};
+export type BinctlProjectDescription = BinctlProject & {
+    orgId: string | null;
+};
+export type BinctlBranch = {
+    branchName: string;
+    sessionCount: number;
+    lastSessionAt: string | null;
+};
+export type BinctlSessionSummary = {
+    id: string;
+    name: string | null;
+    branchName: string;
+    createdAt: string;
+    updatedAt: string;
+};
+export type BinctlSessionDescription = {
+    id: string;
+    projectId: string;
+    projectSlug: string | null;
+    projectName: string | null;
+    branchName: string;
+    name: string | null;
+    fixedMode?: ChatMode | null;
+    fixedTier?: ModelTier | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type BinctlPendingQuestionOption = {
+    id: string;
+    label: string;
+    description?: string;
+};
+export type BinctlPendingQuestion = {
+    id: string;
+    question: string;
+    allowMultiple?: boolean;
+    options: BinctlPendingQuestionOption[];
+};
+export type BinctlRequiredEnv = {
+    target: "backend" | "frontend";
+    name: string;
+    optional: boolean;
+    generateScript?: string;
+    description: string;
+};
+export type BinctlConversationResponse = {
+    session: BinctlSessionDescription;
+    conversation: unknown;
+    thread: unknown[];
+    pendingQuestions: BinctlPendingQuestion[];
+    requiredEnvs: BinctlRequiredEnv[];
+};
+export type BinctlLoginStartResponse = {
+    requestId: string;
+    pollCode: string;
+    loginUrl: string;
+    expiresAt: string;
+    intervalMs: number;
+};
+export type BinctlLoginPollResponse = {
+    status: "pending";
+    expiresAt: string;
+    intervalMs: number;
+} | {
+    status: "approved";
+    token: string;
+    credentialId: string;
+} | {
+    status: "expired" | "consumed";
+};
+export type BinctlAuthStatusResponse = {
+    authenticated: true;
+    source: "session" | "binctl";
+    user: {
+        id: string;
+        email: string;
+        name: string | null;
+    };
+};
+export type BinctlApiKey = {
+    id: string;
+    name: string;
+    createdAt: string;
+    lastUsedAt: string | null;
+};
+export type BinctlProjectCreateInput = {
+    name?: string;
+    orgId?: string;
+};
+export type BinctlProjectUpdateInput = {
+    name?: string;
+    mode?: "greenfield" | "prod";
+};
+export type BinctlSessionCreateInput = {
+    name?: string;
+    branchName: string;
+};
+export type BinctlSessionUpdateInput = {
+    name: string | null;
+};
+export type BinctlClientOptions = {
+    baseUrl?: string;
+    token?: string;
+    apiKey?: string;
+    fetch?: typeof fetch;
+    headers?: Record<string, string>;
+    authMode?: "bearer" | "headers";
+};
+export declare class BinctlApiError extends Error {
+    readonly status: number;
+    readonly path: string;
+    readonly body: unknown;
+    constructor(message: string, input: {
+        status: number;
+        path: string;
+        body: unknown;
+    });
+}
+export declare class BinctlClient {
+    private readonly fetchImpl;
+    private baseUrl;
+    private token?;
+    private apiKey?;
+    private readonly extraHeaders;
+    private readonly authMode;
+    constructor(options?: BinctlClientOptions);
+    setBaseUrl(baseUrl: string): void;
+    setToken(token?: string): void;
+    setApiKey(apiKey?: string): void;
+    private resolveBearerToken;
+    private request;
+    readonly auth: {
+        loginStart: (input?: {
+            baseUrl?: string;
+        }) => Promise<BinctlLoginStartResponse>;
+        loginPoll: (requestId: string, input: {
+            pollCode: string;
+        }) => Promise<BinctlLoginPollResponse>;
+        logout: () => Promise<{
+            success: boolean;
+            revokedCredential: boolean;
+        }>;
+        status: () => Promise<BinctlAuthStatusResponse>;
+        apiKeys: {
+            create: (input: {
+                name: string;
+            }) => Promise<{
+                id: string;
+                apiKey: string;
+                name: string;
+                createdAt: string;
+            }>;
+            list: () => Promise<BinctlApiKey[]>;
+            revoke: (keyId: string) => Promise<{
+                success: boolean;
+            }>;
+        };
+    };
+    readonly projects: {
+        list: () => Promise<BinctlProject[]>;
+        create: (input?: BinctlProjectCreateInput) => Promise<BinctlProjectDescription>;
+        describe: (projectRef: string) => Promise<BinctlProjectDescription>;
+        update: (projectRef: string, input: BinctlProjectUpdateInput) => Promise<BinctlProjectDescription>;
+        delete: (projectRef: string) => Promise<{
+            success: boolean;
+        }>;
+        branches: {
+            list: (projectRef: string) => Promise<BinctlBranch[]>;
+            describe: (projectRef: string, branch: string) => Promise<{
+                project: BinctlProject;
+                branchName: string;
+                sessions: BinctlSessionSummary[];
+            }>;
+        };
+        sessions: {
+            list: (projectRef: string, input?: {
+                branch?: string;
+            }) => Promise<BinctlSessionSummary[]>;
+            create: (projectRef: string, input: BinctlSessionCreateInput) => Promise<BinctlSessionDescription>;
+        };
+    };
+    readonly sessions: {
+        describe: (sessionId: string) => Promise<BinctlSessionDescription>;
+        update: (sessionId: string, input: BinctlSessionUpdateInput) => Promise<BinctlSessionDescription>;
+        delete: (sessionId: string) => Promise<{
+            success: boolean;
+        }>;
+        conversation: (sessionId: string) => Promise<BinctlConversationResponse>;
+        prompt: (sessionId: string, input: {
+            message: string;
+            mode: ChatMode;
+            model: ModelTier;
+        }) => Promise<BinctlConversationResponse>;
+        answerQuestions: (sessionId: string, input: {
+            answers: string[];
+        }) => Promise<BinctlConversationResponse>;
+        applyRequiredEnvs: (sessionId: string, input: {
+            envs: string[];
+        }) => Promise<BinctlConversationResponse>;
+    };
+}

package/package.json

@@ -1,10 +1,31 @@
 {
   "name": "@ricsam/r5d-api",
-  "version": "0.0.1",
-  "description": "OIDC trusted publishing setup package for @ricsam/r5d-api",
-  "keywords": [
-    "oidc",
-    "trusted-publishing",
-    "setup"
-  ]
+  "version": "0.0.3",
+  "type": "module",
+  "main": "./dist/cjs/index.cjs",
+  "module": "./dist/mjs/index.mjs",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/mjs/index.mjs",
+      "require": "./dist/cjs/index.cjs"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ricsam/r5d-dev.git",
+    "directory": "binctl-packages/binctl-api"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "sideEffects": false
 }