@kmlckj/licos-platform-sdk 0.6.5 → 0.6.8

package/src/index.d.ts

@@ -1,251 +0,0 @@
-export class PlatformSdkError extends Error {
-  status?: number;
-  code?: number;
-  details?: unknown;
-}
-
-export class ConfigurationError extends PlatformSdkError {}
-export class ApiError extends PlatformSdkError {}
-
-export interface DatabaseFilter {
-  field: string;
-  op: 'eq' | 'neq' | 'gt' | 'gte' | 'lt' | 'lte' | 'in' | 'not_in' | 'is_null' | 'is_not_null' | 'like' | 'ilike' | string;
-  value?: unknown;
-}
-
-export interface DatabaseOrderBy {
-  field: string;
-  direction?: 'asc' | 'desc';
-}
-
-export interface DatabaseRange {
-  from: number;
-  to: number;
-}
-
-export interface DatabaseResponse {
-  data?: Record<string, unknown>[];
-  count?: number;
-  affectedRows?: number;
-  message?: string;
-  [key: string]: unknown;
-}
-
-export interface DatabaseQueryOptions {
-  select?: string | string[];
-  filters?: DatabaseFilter[];
-  orderBy?: DatabaseOrderBy[];
-  range?: DatabaseRange;
-  limit?: number;
-  offset?: number;
-  count?: boolean;
-  head?: boolean;
-}
-
-export interface DatabaseMutationOptions {
-  row?: Record<string, unknown>;
-  rows?: Record<string, unknown>[];
-  values?: Record<string, unknown>;
-  filters?: DatabaseFilter[];
-  updates?: Array<{ filters?: DatabaseFilter[]; values?: Record<string, unknown> }>;
-  deletes?: Array<{ filters?: DatabaseFilter[] }>;
-  conflictKeys?: string[];
-  returning?: boolean;
-}
-
-export interface DatabaseOperation {
-  type: 'query' | 'insert' | 'update' | 'delete' | 'upsert' | string;
-  request: Record<string, unknown>;
-}
-
-export interface DatabaseSchemaColumn {
-  name: string;
-  type?: string;
-  nullable?: boolean;
-  primaryKey?: boolean;
-  defaultValue?: string | null;
-  [key: string]: unknown;
-}
-
-export interface DatabaseSchemaTable {
-  schema?: string;
-  name: string;
-  description?: string | null;
-  columns?: DatabaseSchemaColumn[];
-  indexes?: unknown[];
-  foreignKeys?: unknown[];
-  constraints?: unknown[];
-  [key: string]: unknown;
-}
-
-export interface DatabaseSchema {
-  databaseId?: string;
-  environment?: 'dev' | 'prod' | string;
-  tables?: DatabaseSchemaTable[];
-  views?: unknown[];
-  functions?: unknown[];
-  enums?: unknown[];
-  [key: string]: unknown;
-}
-
-export interface GenerateOrmOptions {
-  language: 'typescript' | 'python' | 'ts' | 'py' | string;
-  orm?: 'drizzle' | 'sqlalchemy' | string;
-}
-
-export interface TableQuery {
-  select(...fields: string[]): TableQuery;
-  filter(field: string, op: string, value?: unknown): TableQuery;
-  eq(field: string, value: unknown): TableQuery;
-  neq(field: string, value: unknown): TableQuery;
-  gt(field: string, value: unknown): TableQuery;
-  gte(field: string, value: unknown): TableQuery;
-  lt(field: string, value: unknown): TableQuery;
-  lte(field: string, value: unknown): TableQuery;
-  in(field: string, value: unknown[]): TableQuery;
-  notIn(field: string, value: unknown[]): TableQuery;
-  isNull(field: string): TableQuery;
-  isNotNull(field: string): TableQuery;
-  like(field: string, value: string): TableQuery;
-  ilike(field: string, value: string): TableQuery;
-  order(field: string, options?: { desc?: boolean }): TableQuery;
-  range(from: number, to: number): TableQuery;
-  limit(value: number): TableQuery;
-  offset(value: number): TableQuery;
-  withCount(options?: { head?: boolean }): TableQuery;
-  execute(): Promise<DatabaseResponse>;
-  single(): Promise<DatabaseResponse>;
-  maybeSingle(): Promise<DatabaseResponse>;
-}
-
-export function query(table: string, options?: DatabaseQueryOptions): Promise<DatabaseResponse>;
-export function single(table: string, options?: DatabaseQueryOptions & { maybe?: boolean }): Promise<DatabaseResponse>;
-export function maybeSingle(table: string, options?: DatabaseQueryOptions): Promise<DatabaseResponse>;
-export function aggregate(table: string, aggregateName: string, options?: { field?: string; groupBy?: string[]; filters?: DatabaseFilter[] }): Promise<DatabaseResponse>;
-export function insert(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
-export function updateRows(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
-export function deleteRows(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
-export function upsert(table: string, options?: DatabaseMutationOptions): Promise<DatabaseResponse>;
-export function transaction(operations: DatabaseOperation[]): Promise<DatabaseResponse[]>;
-export function rpc(functionName: string, args?: Record<string, unknown>): Promise<DatabaseResponse>;
-export function getSchema(): Promise<DatabaseSchema>;
-export function defaultOrm(language: string): string;
-export function generateOrm(schemaPayload: DatabaseSchema, options: GenerateOrmOptions): string;
-export function exportOrm(options: GenerateOrmOptions): Promise<string>;
-export function table(name: string): TableQuery;
-
-export const database: {
-  query: typeof query;
-  single: typeof single;
-  maybeSingle: typeof maybeSingle;
-  aggregate: typeof aggregate;
-  insert: typeof insert;
-  updateRows: typeof updateRows;
-  deleteRows: typeof deleteRows;
-  upsert: typeof upsert;
-  transaction: typeof transaction;
-  rpc: typeof rpc;
-  getSchema: typeof getSchema;
-  defaultOrm: typeof defaultOrm;
-  generateOrm: typeof generateOrm;
-  exportOrm: typeof exportOrm;
-  table: typeof table;
-};
-
-export interface StorageSummary {
-  workspaceId?: string;
-  projectId?: string;
-  scope?: string;
-  bucketName?: string;
-  usedSizeBytes?: number;
-  fileCount?: number;
-  folderCount?: number;
-  serviceEnabled?: boolean;
-  [key: string]: unknown;
-}
-
-export interface StorageFolder {
-  id?: string;
-  workspaceId?: string;
-  projectId?: string;
-  scope?: string;
-  parentId?: string | null;
-  folderName?: string;
-  folderPath?: string;
-  createdAt?: string;
-  updatedAt?: string;
-  [key: string]: unknown;
-}
-
-export interface StorageFile {
-  id?: string;
-  workspaceId?: string;
-  projectId?: string;
-  scope?: string;
-  folderId?: string | null;
-  folderPath?: string;
-  fileName?: string;
-  contentType?: string;
-  sizeBytes?: number;
-  storageBucket?: string;
-  storageKey?: string;
-  downloadUrl?: string;
-  createdAt?: string;
-  updatedAt?: string;
-  [key: string]: unknown;
-}
-
-export interface StorageEntries {
-  currentFolderId?: string | null;
-  currentFolderName?: string;
-  currentFolderPath?: string;
-  breadcrumbs?: unknown[];
-  folders?: StorageFolder[];
-  files?: StorageFile[];
-  [key: string]: unknown;
-}
-
-export interface UploadFileOptions {
-  folderId?: string;
-  fileName?: string;
-  contentType?: string;
-}
-
-export const MAX_UPLOAD_FILE_BYTES: number;
-
-export interface ShareUrlOptions {
-  expirySeconds?: number;
-}
-
-export function summary(): Promise<StorageSummary>;
-export function listFolders(): Promise<StorageFolder[]>;
-export function listEntries(options?: { folderId?: string }): Promise<StorageEntries>;
-export function listFiles(): Promise<StorageFile[]>;
-export function createFolder(folderName: string, options?: { parentId?: string }): Promise<StorageFolder>;
-export function renameFolder(folderId: string, folderName: string): Promise<StorageFolder>;
-export function deleteFolder(folderId: string): Promise<void>;
-export function uploadFile(
-  input: string | Blob | Buffer | Uint8Array,
-  options?: UploadFileOptions,
-): Promise<StorageFile>;
-export function renameFile(fileId: string, fileName: string): Promise<StorageFile>;
-export function moveFile(fileId: string, options?: { folderId?: string }): Promise<StorageFile>;
-export function shareUrl(fileId: string, options?: ShareUrlOptions): Promise<{ url?: string; expiresAt?: string; [key: string]: unknown }>;
-export function objectExists(options?: { fileId?: string; objectKey?: string }): Promise<{ fileId?: string; bucketName?: string; objectKey?: string; exists?: boolean; [key: string]: unknown }>;
-export function deleteFile(fileId: string): Promise<void>;
-
-export const storage: {
-  summary: typeof summary;
-  listFolders: typeof listFolders;
-  listEntries: typeof listEntries;
-  listFiles: typeof listFiles;
-  createFolder: typeof createFolder;
-  renameFolder: typeof renameFolder;
-  deleteFolder: typeof deleteFolder;
-  uploadFile: typeof uploadFile;
-  renameFile: typeof renameFile;
-  moveFile: typeof moveFile;
-  shareUrl: typeof shareUrl;
-  objectExists: typeof objectExists;
-  deleteFile: typeof deleteFile;
-};

package/src/index.js

@@ -1,3 +0,0 @@
-export { PlatformSdkError, ConfigurationError, ApiError } from './shared.js';
-export * from './database.js';
-export * from './storage.js';

package/src/runtime.js

@@ -1,144 +0,0 @@
-import { ConfigurationError } from './shared.js';
-
-const AI_USER_TOKEN_PATH = '/api/v1/internal/auth/ai-user-token';
-const tokenCache = new Map();
-
-export function env(name) {
-  const value = process.env[name];
-  if (typeof value !== 'string') return undefined;
-  const trimmed = value.trim();
-  return trimmed ? trimmed : undefined;
-}
-
-function normalizeBaseUrl(value) {
-  let trimmed = value.trim().replace(/\/+$/, '');
-  if (trimmed.endsWith('/api/v1')) {
-    trimmed = trimmed.slice(0, -'/api/v1'.length);
-  }
-  return trimmed.replace(/\/+$/, '');
-}
-
-function serviceBaseUrl(hostEnv, portEnv, defaultPort) {
-  const host = env(hostEnv);
-  if (!host) return undefined;
-  return `http://${host}:${env(portEnv) || defaultPort}`;
-}
-
-export function platformBaseUrl() {
-  const value =
-    env('LICOS_PLATFORM_API_BASE_URL') ||
-    serviceBaseUrl('AIOS_PLATFORM_SERVICE_HOST', 'AIOS_PLATFORM_SERVICE_PORT', '9100') ||
-    serviceBaseUrl('LICOS_PLATFORM_SERVICE_HOST', 'LICOS_PLATFORM_SERVICE_PORT', '9100') ||
-    serviceBaseUrl('PLATFORM_SERVICE_HOST', 'PLATFORM_SERVICE_PORT', '9100');
-  if (!value) {
-    throw new ConfigurationError('LICOS_PLATFORM_API_BASE_URL is not configured');
-  }
-  return normalizeBaseUrl(value);
-}
-
-export function projectEnvironment(overrideEnvName) {
-  const explicit = ((overrideEnvName ? env(overrideEnvName) : undefined) || '').toLowerCase();
-  if (explicit === 'dev' || explicit === 'prod') return explicit;
-  const projectEnv = (env('LICOS_PROJECT_ENV') || env('AGENT_ENV') || '').toLowerCase();
-  return ['prod', 'production', 'release'].includes(projectEnv) ? 'prod' : 'dev';
-}
-
-function decodeAiTokenPayload(payload) {
-  if (!payload || typeof payload !== 'object') {
-    throw new ConfigurationError('AI user token exchange response is not an object');
-  }
-  if ((payload.code !== undefined && payload.code !== 0) || payload.success === false) {
-    const error = new ConfigurationError(payload.message || 'AI user token exchange failed');
-    error.code = typeof payload.code === 'number' ? payload.code : undefined;
-    error.details = payload;
-    throw error;
-  }
-  const data = payload.data;
-  const token =
-    typeof data === 'string'
-      ? data.trim()
-      : String(data?.accessToken || data?.access_token || data?.token || '').trim();
-  if (!token) {
-    const error = new ConfigurationError('AI user token exchange response missing accessToken');
-    error.details = payload;
-    throw error;
-  }
-  return token;
-}
-
-async function resolveUserToken(baseUrl, userId) {
-  const ownerUserId = String(userId || '').trim();
-  if (!ownerUserId) {
-    throw new ConfigurationError('project owner user ID is not configured');
-  }
-  const aiAgentToken = env('LICOS_AI_AGENT_TOKEN');
-  if (!aiAgentToken) {
-    throw new ConfigurationError('platform runtime identity is unavailable');
-  }
-
-  const cacheKey = `${baseUrl}\n${ownerUserId}\n${aiAgentToken}`;
-  if (tokenCache.has(cacheKey)) return tokenCache.get(cacheKey);
-
-  const promise = fetch(`${baseUrl}${AI_USER_TOKEN_PATH}`, {
-    method: 'POST',
-    headers: {
-      Authorization: `Bearer ${aiAgentToken}`,
-      'Content-Type': 'application/json',
-    },
-    body: JSON.stringify({ userId: ownerUserId }),
-  }).then(async (response) => {
-    const text = await response.text();
-    let payload = null;
-    try {
-      payload = text ? JSON.parse(text) : null;
-    } catch (error) {
-      const wrapped = new ConfigurationError('parse AI user token exchange response failed');
-      wrapped.status = response.status;
-      wrapped.details = text;
-      throw wrapped;
-    }
-    if (!response.ok) {
-      const message = payload?.message || text || `AI user token exchange returned ${response.status}`;
-      const wrapped = new ConfigurationError(message);
-      wrapped.status = response.status;
-      wrapped.details = payload;
-      throw wrapped;
-    }
-    return decodeAiTokenPayload(payload);
-  });
-  tokenCache.set(cacheKey, promise);
-  try {
-    return await promise;
-  } catch (error) {
-    tokenCache.delete(cacheKey);
-    throw error;
-  }
-}
-
-export async function runtimeConfig({ environmentOverrideEnv } = {}) {
-  const projectId = env('LICOS_PROJECT_ID') || env('AGENT_PROJECT_ID');
-  if (!projectId) {
-    throw new ConfigurationError('LICOS_PROJECT_ID or AGENT_PROJECT_ID is not configured');
-  }
-  const baseUrl = platformBaseUrl();
-  const userId = env('LICOS_USER_ID') || env('AGENT_USER_ID');
-  const token = await resolveUserToken(baseUrl, userId);
-  return {
-    baseUrl,
-    projectId,
-    environment: projectEnvironment(environmentOverrideEnv),
-    token,
-    workspaceId: env('LICOS_WORKSPACE_ID') || env('AGENT_WORKSPACE_ID'),
-    userId,
-  };
-}
-
-export function authHeaders(config, contentType = 'application/json') {
-  const result = {
-    Authorization: `Bearer ${config.token}`,
-  };
-  if (contentType) result['Content-Type'] = contentType;
-  if (config.workspaceId) result['X-Workspace-Id'] = config.workspaceId;
-  if (config.userId) result['X-User-Id'] = config.userId;
-  return result;
-}

package/src/shared.js

@@ -1,12 +0,0 @@
-export class PlatformSdkError extends Error {
-  constructor(message, options = {}) {
-    super(message);
-    this.name = new.target.name;
-    this.status = options.status;
-    this.code = options.code;
-    this.details = options.details;
-  }
-}
-
-export class ConfigurationError extends PlatformSdkError {}
-export class ApiError extends PlatformSdkError {}

package/src/storage.js

@@ -1,167 +0,0 @@
-import { readFile, stat } from 'node:fs/promises';
-import path from 'node:path';
-
-import { ApiError } from './shared.js';
-import { authHeaders, runtimeConfig } from './runtime.js';
-
-export const MAX_UPLOAD_FILE_BYTES = 20 * 1024 * 1024;
-
-async function storageConfig() {
-  return runtimeConfig({ environmentOverrideEnv: 'LICOS_STORAGE_SCOPE' });
-}
-
-function query(config, params = {}) {
-  const search = new URLSearchParams();
-  search.set('projectId', config.projectId);
-  search.set('scope', config.environment);
-  for (const [key, value] of Object.entries(params)) {
-    if (value !== undefined && value !== null) search.set(key, String(value));
-  }
-  return search.toString();
-}
-
-function storageUrl(config, route, params) {
-  return `${config.baseUrl}/api/v1/studio/storage${route}?${query(config, params)}`;
-}
-
-async function decodeResponse(response) {
-  const text = await response.text();
-  const payload = text ? JSON.parse(text) : null;
-  if (!response.ok) {
-    throw new ApiError(text || `platform storage API returned ${response.status}`, {
-      status: response.status,
-      details: payload,
-    });
-  }
-  if (!payload || typeof payload !== 'object') return payload;
-  if ((payload.code !== undefined && payload.code !== 0) || payload.success === false) {
-    throw new ApiError(payload.message || 'platform storage API failed', {
-      status: response.status,
-      code: typeof payload.code === 'number' ? payload.code : undefined,
-      details: payload,
-    });
-  }
-  return payload.data;
-}
-
-async function requestJson(method, route, { params, body } = {}) {
-  const config = await storageConfig();
-  const response = await fetch(storageUrl(config, route, params), {
-    method,
-    headers: authHeaders(config),
-    body: body === undefined ? undefined : JSON.stringify(body),
-  });
-  return decodeResponse(response);
-}
-
-async function filePart(input, options = {}) {
-  if (typeof input === 'string') {
-    const info = await stat(input);
-    ensureUploadSize(info.size);
-    const data = await readFile(input);
-    return {
-      blob: new Blob([data], { type: options.contentType || 'application/octet-stream' }),
-      fileName: options.fileName || path.basename(input),
-    };
-  }
-  if (input instanceof Blob) {
-    ensureUploadSize(input.size);
-    return { blob: input, fileName: options.fileName || 'file' };
-  }
-  if (input instanceof Uint8Array || Buffer.isBuffer(input)) {
-    ensureUploadSize(input.byteLength);
-    return {
-      blob: new Blob([input], { type: options.contentType || 'application/octet-stream' }),
-      fileName: options.fileName || 'file',
-    };
-  }
-  throw new TypeError('uploadFile input must be a file path, Blob, Buffer, or Uint8Array');
-}
-
-function ensureUploadSize(size) {
-  if (size > MAX_UPLOAD_FILE_BYTES) {
-    throw new RangeError(`uploadFile input exceeds max size of ${MAX_UPLOAD_FILE_BYTES} bytes`);
-  }
-}
-
-export async function summary() {
-  return requestJson('GET', '/summary');
-}
-
-export async function listFolders() {
-  return (await requestJson('GET', '/folders')) || [];
-}
-
-export async function listEntries({ folderId } = {}) {
-  return requestJson('GET', '/entries', { params: { folderId } });
-}
-
-export async function listFiles() {
-  return (await requestJson('GET', '/files')) || [];
-}
-
-export async function createFolder(folderName, { parentId } = {}) {
-  return requestJson('POST', '/folders', { body: { folderName, parentId } });
-}
-
-export async function renameFolder(folderId, folderName) {
-  return requestJson('PUT', `/folders/${encodeURIComponent(folderId)}`, { body: { folderName } });
-}
-
-export async function deleteFolder(folderId) {
-  await requestJson('DELETE', `/folders/${encodeURIComponent(folderId)}`);
-}
-
-export async function uploadFile(input, options = {}) {
-  const { blob, fileName } = await filePart(input, options);
-  const config = await storageConfig();
-  const form = new FormData();
-  form.set('projectId', config.projectId);
-  form.set('scope', config.environment);
-  if (options.folderId) form.set('folderId', options.folderId);
-  form.set('file', blob, fileName);
-  const response = await fetch(`${config.baseUrl}/api/v1/studio/storage/files/upload`, {
-    method: 'POST',
-    headers: authHeaders(config, undefined),
-    body: form,
-  });
-  return decodeResponse(response);
-}
-
-export async function renameFile(fileId, fileName) {
-  return requestJson('PUT', `/files/${encodeURIComponent(fileId)}/rename`, { body: { fileName } });
-}
-
-export async function moveFile(fileId, { folderId } = {}) {
-  return requestJson('PUT', `/files/${encodeURIComponent(fileId)}/move`, { body: { folderId } });
-}
-
-export async function shareUrl(fileId, { expirySeconds } = {}) {
-  return requestJson('POST', `/files/${encodeURIComponent(fileId)}/share-url`, {
-    body: { expirySeconds },
-  });
-}
-
-export async function objectExists({ fileId, objectKey } = {}) {
-  return requestJson('POST', '/objects/exists', { body: { fileId, objectKey } });
-}
-
-export async function deleteFile(fileId) {
-  await requestJson('DELETE', `/files/${encodeURIComponent(fileId)}`);
-}
-
-export const storage = {
-  summary,
-  listFolders,
-  listEntries,
-  listFiles,
-  createFolder,
-  renameFolder,
-  deleteFolder,
-  uploadFile,
-  renameFile,
-  moveFile,
-  shareUrl,
-  objectExists,
-  deleteFile,
-};