@ours.network/fleet 1.0.3 → 1.0.5

package/dist/application/task-room-service.d.ts

@@ -0,0 +1,262 @@
+import { type FleetConfig } from '../config.js';
+import { type CoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
+import { provisionMembers } from '../rooms-tasks/provision.js';
+import { moveTaskToList } from '../rooms-tasks/task-state.js';
+import type { RoomOrchestrationRecord, TaskListRecord, TaskOrigin, TaskOutcome, TaskRecord, TaskState } from '../rooms-tasks/types.js';
+export type TaskRoomActor = {
+    kind: 'local_control';
+    surface: 'cli' | 'web';
+} | {
+    kind: 'authenticated_owner';
+    surface: 'messenger';
+    cid: string;
+} | {
+    kind: 'internal_worker';
+    surface: 'cli';
+};
+export interface TaskSettlementPlan {
+    task: TaskRecord;
+    settlementRequired: boolean;
+}
+export type TaskRecoveryIssue = {
+    code: 'terminal_pending' | 'waiting_cowork' | 'waiting_owner_invite' | 'owner_cid_mismatch' | 'waiting_seats' | 'provisioning_resumed';
+} | {
+    code: 'member_failed';
+    stepIndex: number;
+} | {
+    code: 'resume_failed';
+    error: string;
+};
+export interface TaskRecoveryResult {
+    kind: 'provisioning_resumed' | 'provisioning_resume_failed' | 'provisioning_non_resumable' | 'terminal' | 'no_op';
+    task: TaskRecord;
+    room: RoomOrchestrationRecord | undefined;
+    issues: TaskRecoveryIssue[];
+    reason?: 'missing_room' | 'missing_durable_template' | 'non_resumable_phase';
+}
+export type TaskRecoveryBegin = {
+    kind: 'terminal_worker_required';
+    taskId: string;
+} | {
+    kind: 'final';
+    result: TaskRecoveryResult;
+};
+export declare class TaskRoomApplicationError extends Error {
+    readonly code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'room_not_found' | 'room_record_not_found';
+    readonly fields: Readonly<Record<string, string>>;
+    constructor(code: 'template_not_found' | 'task_template_drift' | 'template_mismatch' | 'task_terminal' | 'task_terminal_already' | 'task_non_resumable' | 'room_not_found' | 'room_record_not_found', message: string, fields?: Readonly<Record<string, string>>);
+}
+export interface CreateTaskRequest {
+    actor: TaskRoomActor;
+    title: string;
+    brief?: string;
+    briefFile?: string;
+    template?: string;
+    backlog?: boolean;
+    noRoom?: boolean;
+    idempotencyKey?: string;
+    origin: TaskOrigin;
+    list?: string;
+}
+export interface CreateRoomRequest {
+    actor: TaskRoomActor;
+    name: string;
+    template?: string;
+    goal?: string;
+    brief?: string;
+    briefFile?: string;
+}
+export interface TaskRoomServiceDeps {
+    loadConfiguration?(path?: string): FleetConfig;
+    cowork?(config: FleetConfig): CoworkAdapter;
+    binPath?(): string;
+    provisionMembers?: typeof provisionMembers;
+    moveTaskToList?: typeof moveTaskToList;
+}
+/** Exact extraction of the previously CLI-owned task create/start behavior. */
+export declare class TaskRoomApplicationService {
+    private readonly configurationPath?;
+    private readonly deps;
+    private recovery?;
+    constructor(configurationPath?: string | undefined, deps?: TaskRoomServiceDeps);
+    createTask(request: CreateTaskRequest): Promise<TaskRecord>;
+    createRoom(request: CreateRoomRequest): Promise<RoomOrchestrationRecord>;
+    startTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): Promise<TaskRecord>;
+    listTasks(filter?: {
+        state?: TaskState | TaskState[];
+        list?: string;
+    }): TaskRecord[];
+    listTaskLists(): TaskListRecord[];
+    groupedTasks(filter?: {
+        state?: TaskState | TaskState[];
+        list?: string;
+    }): Array<{
+        list: TaskListRecord;
+        tasks: TaskRecord[];
+    }>;
+    createTaskList(input: {
+        actor: TaskRoomActor;
+        name: string;
+    }): Promise<TaskListRecord>;
+    renameTaskList(input: {
+        actor: TaskRoomActor;
+        name: string;
+        newName: string;
+    }): Promise<TaskListRecord>;
+    moveTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        list: string;
+    }): Promise<TaskRecord>;
+    deleteTaskList(input: {
+        actor: TaskRoomActor;
+        name: string;
+        destination?: string;
+    }): Promise<{
+        deleted: TaskListRecord;
+        moved: number;
+        destination?: TaskListRecord;
+    }>;
+    getTask(taskId: string): {
+        task: TaskRecord;
+        orchestration: RoomOrchestrationRecord | undefined;
+    };
+    blockTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        reason: string;
+    }): TaskRecord;
+    unblockTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): TaskRecord;
+    reviewTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): TaskRecord;
+    deleteTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): boolean;
+    completeTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        outcome?: TaskOutcome;
+    }): Promise<TaskSettlementPlan>;
+    cancelTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): Promise<TaskSettlementPlan>;
+    settleTask(input: {
+        actor: {
+            kind: 'internal_worker';
+            surface: 'cli';
+        };
+        taskId: string;
+    }): Promise<TaskRecord>;
+    recordSettlementError(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        error: string;
+        recoveryHint: string;
+    }): Promise<TaskRecord>;
+    beginTaskRecovery(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+    }): Promise<TaskRecoveryBegin>;
+    continueTaskRecovery(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        terminalTimedOut: boolean;
+    }): Promise<TaskRecoveryResult>;
+    private acceptTerminal;
+    listTemplates(): import("../rooms-tasks/types.js").TemplateDefinition[];
+    getTemplate(name: string): {
+        content_hash: string;
+        name: string;
+        version: number;
+        description: string;
+        builtin?: boolean;
+        room?: import("../rooms-tasks/types.js").TemplateRoomConfig;
+        contract?: string;
+        members: import("../rooms-tasks/types.js").TemplateMemberSlot[];
+    };
+    validateTemplates(): {
+        template: string;
+        issues: string[];
+    }[];
+    listRooms(filter?: {
+        state?: 'active' | 'provisioning';
+    }): Promise<{
+        orchestration: RoomOrchestrationRecord | null;
+        room_id: string;
+        identity_name: string;
+        identity_cid: string;
+        room_name: string;
+        state: "provisioning" | "active" | "closing" | "closed";
+        seats: import("../rooms-tasks/cowork-adapter.js").CoworkSeatInfo[];
+        goal?: string;
+        briefing?: string;
+        role_briefings: Record<string, import("../rooms-tasks/cowork-adapter.js").CoworkRoleBriefingInfo>;
+    }[]>;
+    getRoomDetail(id: string): Promise<{
+        room: import("../rooms-tasks/cowork-adapter.js").CoworkRoomInfo;
+        orchestration: RoomOrchestrationRecord | undefined;
+    }>;
+    getRoomMembers(id: string): Promise<{
+        room: import("../rooms-tasks/cowork-adapter.js").CoworkRoomInfo;
+        orchestration: RoomOrchestrationRecord | undefined;
+        members: import("../rooms-tasks/cowork-adapter.js").CoworkSeatInfo[];
+    }>;
+    requestRoomDeletion(input: {
+        actor: TaskRoomActor;
+        roomId: string;
+    }): Promise<{
+        room: RoomOrchestrationRecord;
+        settlementRequired: true;
+    }>;
+    settleRoomDeletion(input: {
+        actor: {
+            kind: 'internal_worker';
+            surface: 'cli';
+        };
+        roomId: string;
+    }): Promise<import("../rooms-tasks/close.js").ManagedRoomDeleteResult>;
+    recordRoomSettlementError(input: {
+        actor: TaskRoomActor;
+        roomId: string;
+        error: string;
+        recoveryHint: string;
+    }): Promise<RoomOrchestrationRecord>;
+    recoverRoom(input: {
+        actor: TaskRoomActor;
+        roomId: string;
+    }): Promise<{
+        kind: 'deletion_worker_required';
+        roomId: string;
+    } | {
+        kind: 'recovered' | 'provisioning_resumed' | 'provisioning_resume_failed';
+        room: Awaited<ReturnType<CoworkAdapter['recoverRoom']>>;
+        orchestration: RoomOrchestrationRecord | undefined;
+        issues: string[];
+    }>;
+    finishTask(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        outcome?: TaskOutcome;
+    }): Promise<TaskSettlementPlan>;
+    ensureTaskWork(input: {
+        actor: TaskRoomActor;
+        taskId: string;
+        template?: string;
+    }): Promise<{
+        task: TaskRecord;
+        status: 'ready' | 'already_active';
+    }>;
+    private createTemplate;
+    private existingTemplate;
+    private provisionRoom;
+}