colonies-ts 0.1.2 → 0.1.3

package/README.md

@@ -275,6 +275,7 @@ new ColoniesClient({
 | `getProcesses(colonyName, count, state)` | List processes by state |
 | `closeProcess(processId, output)` | Close a process successfully |
 | `failProcess(processId, errors)` | Close a process with failure |
+| `cancelProcess(processId)` | Cancel a running process |
 | `removeProcess(processId)` | Remove a process |
 | `removeAllProcesses(colonyName, state)` | Remove all processes |
 
@@ -286,6 +287,7 @@ new ColoniesClient({
 | `getProcessGraph(graphId)` | Get workflow details |
 | `getProcessGraphs(colonyName, count, state?)` | List workflows |
 | `getProcessesForWorkflow(graphId, colonyName, count?)` | Get processes for a workflow |
+| `cancelProcessGraph(graphId)` | Cancel a running workflow |
 | `removeProcessGraph(graphId)` | Remove a workflow |
 | `removeAllProcessGraphs(colonyName, state?)` | Remove all workflows |
 

package/dist/index.d.mts

@@ -79,6 +79,147 @@ declare enum ProcessState {
     SUCCESS = 2,
     FAILED = 3
 }
+interface Colony {
+    colonyid: string;
+    name: string;
+}
+interface User {
+    colonyname: string;
+    userid: string;
+    name: string;
+    email: string;
+    phone: string;
+}
+interface Executor {
+    executorid: string;
+    executortype: string;
+    executorname: string;
+    colonyname: string;
+    approved?: boolean;
+}
+interface Process {
+    processid: string;
+    processgraphid?: string;
+    state: ProcessState;
+    spec: FunctionSpec;
+    assignedexecutorname?: string;
+    assignedexecutortype?: string;
+    waitingtime?: number;
+    exectime?: number;
+    out?: string[];
+    errors?: string[];
+    submissiontime?: string;
+    starttime?: string;
+    endtime?: string;
+}
+interface WorkflowSpec {
+    colonyname: string;
+    functionspecs: FunctionSpec[];
+}
+interface ProcessGraph {
+    processgraphid: string;
+    state: ProcessState;
+    colonyname?: string;
+    roots?: string[];
+}
+interface FunctionArg {
+    name: string;
+    type: string;
+    description?: string;
+    required?: boolean;
+    enum?: string[];
+}
+interface ColonyFunction {
+    funcname: string;
+    executorname: string;
+    executortype: string;
+    colonyname: string;
+    description?: string;
+    locationname?: string;
+    args?: FunctionArg[];
+}
+interface ColonyFile {
+    fileid?: string;
+    colonyname: string;
+    label: string;
+    name: string;
+    size: number;
+    checksum: string;
+    checksumalg: string;
+    ref: {
+        protocol: string;
+        s3object: {
+            server: string;
+            port: number;
+            tls: boolean;
+            accesskey: string;
+            secretkey: string;
+            region: string;
+            bucket: string;
+            object: string;
+        };
+    };
+}
+interface Attribute {
+    attributeid?: string;
+    targetid: string;
+    targetcolonyname: string;
+    targetprocessgraphid: string;
+    attributetype: number;
+    key: string;
+    value: string;
+}
+interface Cron {
+    cronid?: string;
+    colonyname: string;
+    name: string;
+    cron: string;
+    workflowspec?: WorkflowSpec;
+    nextrun?: string;
+    lastrun?: string;
+    checkin?: string;
+}
+interface Generator {
+    generatorid?: string;
+    colonyname: string;
+    name: string;
+    workflowspec?: WorkflowSpec;
+    trigger?: number;
+    timeout?: number;
+    lastrun?: string;
+}
+interface BlueprintMetadata {
+    name: string;
+    colonyname: string;
+    [key: string]: unknown;
+}
+interface BlueprintHandler {
+    executortype: string;
+}
+interface BlueprintDefinition {
+    kind: string;
+    metadata: BlueprintMetadata;
+    spec?: Record<string, unknown>;
+}
+interface Blueprint {
+    blueprintid?: string;
+    kind: string;
+    metadata: BlueprintMetadata;
+    handler?: BlueprintHandler;
+    spec: Record<string, unknown>;
+    status?: Record<string, unknown>;
+}
+interface ChannelEntry {
+    sequence: number;
+    inreplyto: number;
+    payload: string;
+}
+interface Log {
+    processid?: string;
+    executorname?: string;
+    message: string;
+    timestamp?: string;
+}
 declare class ColoniesClient {
     private host;
     private port;
@@ -90,86 +231,76 @@ declare class ColoniesClient {
     private getBaseUrl;
     private createRPCMsg;
     private sendRPC;
-    getColonies(): Promise<any>;
+    getColonies(): Promise<Colony[]>;
     getStatistics(): Promise<any>;
     /**
      * Add a new colony (requires server private key)
      * @param colony - Colony object with colonyid and name
      */
-    addColony(colony: {
-        colonyid: string;
-        name: string;
-    }): Promise<any>;
+    addColony(colony: Colony): Promise<Colony>;
     /**
      * Remove a colony (requires server private key)
      * @param colonyName - Name of the colony to remove
      */
-    removeColony(colonyName: string): Promise<any>;
-    getExecutors(colonyName: string): Promise<any>;
-    getExecutor(colonyName: string, executorName: string): Promise<any>;
-    addExecutor(executor: {
-        executorid: string;
-        executortype: string;
-        executorname: string;
-        colonyname: string;
-    }): Promise<any>;
-    approveExecutor(colonyName: string, executorName: string): Promise<any>;
-    removeExecutor(colonyName: string, executorName: string): Promise<any>;
-    submitFunctionSpec(spec: FunctionSpec): Promise<any>;
-    getProcess(processId: string): Promise<any>;
-    getProcesses(colonyName: string, count: number, state: ProcessState): Promise<any>;
-    removeProcess(processId: string): Promise<any>;
-    removeAllProcesses(colonyName: string, state?: number): Promise<any>;
-    assign(colonyName: string, timeout: number, executorPrvKey: string): Promise<any>;
-    closeProcess(processId: string, output: string[]): Promise<any>;
-    failProcess(processId: string, errors: string[]): Promise<any>;
-    submitWorkflowSpec(workflowSpec: {
-        colonyname: string;
-        functionspecs: FunctionSpec[];
-    }): Promise<any>;
-    getProcessGraph(processGraphId: string): Promise<any>;
-    getProcessGraphs(colonyName: string, count: number, state?: ProcessState): Promise<any>;
-    removeProcessGraph(processGraphId: string): Promise<any>;
-    getProcessesForWorkflow(processGraphId: string, colonyName: string, count?: number): Promise<any>;
-    removeAllProcessGraphs(colonyName: string, state?: ProcessState): Promise<any>;
-    addLog(processId: string, message: string, executorPrvKey: string): Promise<any>;
-    getLogs(colonyName: string, processId: string, executorName: string, count?: number, since?: number): Promise<any>;
-    getFunctions(executorName: string, colonyName: string): Promise<any>;
-    getCrons(colonyName: string, count?: number): Promise<any>;
-    getCron(cronId: string): Promise<any>;
-    addCron(cronSpec: any): Promise<any>;
-    removeCron(cronId: string): Promise<any>;
-    runCron(cronId: string): Promise<any>;
-    getGenerators(colonyName: string, count?: number): Promise<any>;
-    getGenerator(generatorId: string): Promise<any>;
-    addGenerator(generatorSpec: any): Promise<any>;
-    getUsers(colonyName: string): Promise<any>;
-    addUser(user: {
-        colonyname: string;
-        userid: string;
-        name: string;
-        email: string;
-        phone: string;
-    }): Promise<any>;
-    removeUser(colonyName: string, name: string): Promise<any>;
-    getFileLabels(colonyName: string, name?: string, exact?: boolean): Promise<any>;
-    getFiles(colonyName: string, label: string): Promise<any>;
+    removeColony(colonyName: string): Promise<void>;
+    getExecutors(colonyName: string): Promise<Executor[]>;
+    getExecutor(colonyName: string, executorName: string): Promise<Executor>;
+    addExecutor(executor: Executor): Promise<Executor>;
+    approveExecutor(colonyName: string, executorName: string): Promise<Executor>;
+    removeExecutor(colonyName: string, executorName: string): Promise<void>;
+    submitFunctionSpec(spec: FunctionSpec): Promise<Process>;
+    getProcess(processId: string): Promise<Process>;
+    getProcesses(colonyName: string, count: number, state: ProcessState): Promise<Process[]>;
+    removeProcess(processId: string): Promise<void>;
+    removeAllProcesses(colonyName: string, state?: number): Promise<void>;
+    assign(colonyName: string, timeout: number, executorPrvKey: string): Promise<Process>;
+    closeProcess(processId: string, output: string[]): Promise<void>;
+    failProcess(processId: string, errors: string[]): Promise<void>;
+    cancelProcess(processId: string): Promise<void>;
+    submitWorkflowSpec(workflowSpec: WorkflowSpec): Promise<ProcessGraph>;
+    getProcessGraph(processGraphId: string): Promise<ProcessGraph>;
+    getProcessGraphs(colonyName: string, count: number, state?: ProcessState): Promise<ProcessGraph[]>;
+    removeProcessGraph(processGraphId: string): Promise<void>;
+    getProcessesForWorkflow(processGraphId: string, colonyName: string, count?: number): Promise<Process[]>;
+    cancelProcessGraph(processGraphId: string): Promise<void>;
+    removeAllProcessGraphs(colonyName: string, state?: ProcessState): Promise<void>;
+    addLog(processId: string, message: string, executorPrvKey: string): Promise<void>;
+    getLogs(colonyName: string, processId: string, executorName: string, count?: number, since?: number): Promise<Log[]>;
+    addFunction(func: ColonyFunction): Promise<ColonyFunction>;
+    getFunctions(executorName: string, colonyName: string): Promise<ColonyFunction[]>;
+    getCrons(colonyName: string, count?: number): Promise<Cron[]>;
+    getCron(cronId: string): Promise<Cron>;
+    addCron(cronSpec: Cron): Promise<Cron>;
+    removeCron(cronId: string): Promise<void>;
+    runCron(cronId: string): Promise<void>;
+    getGenerators(colonyName: string, count?: number): Promise<Generator[]>;
+    getGenerator(generatorId: string): Promise<Generator>;
+    addGenerator(generatorSpec: Generator): Promise<Generator>;
+    getUsers(colonyName: string): Promise<User[]>;
+    addUser(user: User): Promise<User>;
+    removeUser(colonyName: string, name: string): Promise<void>;
+    getFileLabels(colonyName: string, name?: string, exact?: boolean): Promise<string[]>;
+    getFiles(colonyName: string, label: string): Promise<ColonyFile[]>;
     getFile(colonyName: string, options: {
         fileId: string;
     } | {
         name: string;
         label: string;
         latest?: boolean;
-    }): Promise<any>;
-    addAttribute(attribute: {
-        targetid: string;
-        targetcolonyname: string;
-        targetprocessgraphid: string;
-        attributetype: number;
-        key: string;
-        value: string;
-    }): Promise<any>;
-    getAttribute(attributeId: string): Promise<any>;
+    }): Promise<ColonyFile>;
+    /**
+     * Register a file in ColonyFS
+     * @param file - File metadata including colony, label, name, size, checksum, and S3 reference
+     */
+    addFile(file: ColonyFile): Promise<ColonyFile>;
+    /**
+     * Remove a file from ColonyFS
+     * @param colonyName - Name of the colony
+     * @param fileId - ID of the file to remove
+     */
+    removeFile(colonyName: string, fileId: string): Promise<void>;
+    addAttribute(attribute: Attribute): Promise<Attribute>;
+    getAttribute(attributeId: string): Promise<Attribute>;
     /**
      * Append a message to a process channel
      * @param processId - ID of the process
@@ -178,7 +309,7 @@ declare class ColoniesClient {
      * @param inReplyTo - Sequence number this message is replying to (0 if not a reply)
      * @param payload - Message content (string or Uint8Array)
      */
-    channelAppend(processId: string, channelName: string, sequence: number, inReplyTo: number, payload: string | Uint8Array): Promise<any>;
+    channelAppend(processId: string, channelName: string, sequence: number, inReplyTo: number, payload: string | Uint8Array): Promise<void>;
     /**
      * Read messages from a process channel
      * @param processId - ID of the process
@@ -186,7 +317,7 @@ declare class ColoniesClient {
      * @param afterSeq - Read messages after this sequence number (use 0 for all)
      * @param limit - Maximum number of messages to return (0 for no limit)
      */
-    channelRead(processId: string, channelName: string, afterSeq: number, limit: number): Promise<any[]>;
+    channelRead(processId: string, channelName: string, afterSeq: number, limit: number): Promise<ChannelEntry[]>;
     /**
      * Subscribe to a channel using WebSocket for real-time updates
      * @param processId - ID of the process
@@ -198,23 +329,23 @@ declare class ColoniesClient {
      * @param onClose - Callback when connection closes
      * @returns WebSocket instance for cleanup
      */
-    subscribeChannel(processId: string, channelName: string, afterSeq: number, timeout: number, onMessage: (entries: any[]) => void, onError: (error: Error) => void, onClose: () => void): WebSocket;
+    subscribeChannel(processId: string, channelName: string, afterSeq: number, timeout: number, onMessage: (entries: ChannelEntry[]) => void, onError: (error: Error) => void, onClose: () => void): WebSocket;
     /**
      * Add a blueprint definition
      * @param definition - Blueprint definition object
      */
-    addBlueprintDefinition(definition: any): Promise<any>;
+    addBlueprintDefinition(definition: BlueprintDefinition): Promise<BlueprintDefinition>;
     /**
      * Get a blueprint definition by name
      * @param colonyName - Name of the colony
      * @param name - Name of the blueprint definition
      */
-    getBlueprintDefinition(colonyName: string, name: string): Promise<any>;
+    getBlueprintDefinition(colonyName: string, name: string): Promise<BlueprintDefinition>;
     /**
      * Get all blueprint definitions in a colony
      * @param colonyName - Name of the colony
      */
-    getBlueprintDefinitions(colonyName: string): Promise<any[]>;
+    getBlueprintDefinitions(colonyName: string): Promise<BlueprintDefinition[]>;
     /**
      * Remove a blueprint definition
      * @param colonyName - Name of the colony (namespace)
@@ -225,26 +356,26 @@ declare class ColoniesClient {
      * Add a blueprint instance
      * @param blueprint - Blueprint object
      */
-    addBlueprint(blueprint: any): Promise<any>;
+    addBlueprint(blueprint: Blueprint): Promise<Blueprint>;
     /**
      * Get a blueprint by name
      * @param colonyName - Name of the colony (namespace)
      * @param name - Name of the blueprint
      */
-    getBlueprint(colonyName: string, name: string): Promise<any>;
+    getBlueprint(colonyName: string, name: string): Promise<Blueprint>;
     /**
      * Get blueprints in a colony, optionally filtered by kind and location
      * @param colonyName - Name of the colony (namespace)
      * @param kind - Optional kind filter
      * @param location - Optional location filter
      */
-    getBlueprints(colonyName: string, kind?: string, location?: string): Promise<any[]>;
+    getBlueprints(colonyName: string, kind?: string, location?: string): Promise<Blueprint[]>;
     /**
      * Update an existing blueprint
      * @param blueprint - Updated blueprint object
      * @param forceGeneration - Force generation bump even if spec unchanged
      */
-    updateBlueprint(blueprint: any, forceGeneration?: boolean): Promise<any>;
+    updateBlueprint(blueprint: Blueprint, forceGeneration?: boolean): Promise<Blueprint>;
     /**
      * Remove a blueprint
      * @param colonyName - Name of the colony (namespace)
@@ -257,20 +388,20 @@ declare class ColoniesClient {
      * @param name - Name of the blueprint
      * @param status - Status object representing current state
      */
-    updateBlueprintStatus(colonyName: string, name: string, status: any): Promise<void>;
+    updateBlueprintStatus(colonyName: string, name: string, status: Record<string, unknown>): Promise<void>;
     /**
      * Trigger reconciliation for a blueprint
      * @param colonyName - Name of the colony (namespace)
      * @param name - Name of the blueprint
      * @param force - Force reconciliation even if no changes detected
      */
-    reconcileBlueprint(colonyName: string, name: string, force?: boolean): Promise<any>;
+    reconcileBlueprint(colonyName: string, name: string, force?: boolean): Promise<Blueprint>;
     /**
      * Get the history of changes for a specific blueprint
      * @param blueprintId - ID of the blueprint
      * @param limit - Optional limit on number of history entries to retrieve
      */
-    getBlueprintHistory(blueprintId: string, limit?: number): Promise<any>;
+    getBlueprintHistory(blueprintId: string, limit?: number): Promise<Blueprint[]>;
     /**
      * Subscribe to process state changes using WebSocket
      * Use this to wait for a process to be assigned (RUNNING state) before subscribing to channels
@@ -283,7 +414,7 @@ declare class ColoniesClient {
      * @param onClose - Callback when connection closes
      * @returns WebSocket instance for cleanup
      */
-    subscribeProcess(colonyName: string, processId: string, state: number, timeout: number, onProcess: (process: any) => void, onError: (error: Error) => void, onClose: () => void): WebSocket;
+    subscribeProcess(colonyName: string, processId: string, state: number, timeout: number, onProcess: (process: Process) => void, onError: (error: Error) => void, onClose: () => void): WebSocket;
 }
 
-export { ColoniesClient, type ColoniesClientConfig, Crypto, type FunctionSpec, ProcessState, type RPCMessage, deriveId, generatePrivateKey, sign };
+export { type Attribute, type Blueprint, type BlueprintDefinition, type BlueprintHandler, type BlueprintMetadata, type ChannelEntry, ColoniesClient, type ColoniesClientConfig, type Colony, type ColonyFile, type ColonyFunction, type Cron, Crypto, type Executor, type FunctionArg, type FunctionSpec, type Generator, type Log, type Process, type ProcessGraph, ProcessState, type RPCMessage, type User, type WorkflowSpec, deriveId, generatePrivateKey, sign };