@ours.network/fleet 1.0.3 → 1.0.5

package/dist/rooms-tasks/task-lists.d.ts

@@ -0,0 +1,19 @@
+import type { TaskListRecord } from './types.js';
+export declare const DEFAULT_TASK_LIST_ID = "default";
+export declare const TASK_LIST_NAME_MAX_CODE_POINTS = 64;
+export declare class TaskListError extends Error {
+    readonly code: 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'list_not_found' | 'default_immutable' | 'destination_required' | 'same_destination';
+    constructor(code: 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'list_not_found' | 'default_immutable' | 'destination_required' | 'same_destination', message: string);
+}
+export declare const taskListsPath: () => string;
+export declare const taskListsLockPath: () => string;
+export declare const withTaskListsLock: <T>(fn: () => T | Promise<T>) => Promise<T>;
+export declare function normalizeTaskListName(input: string): string;
+export declare function readTaskLists(): TaskListRecord[];
+export declare function resolveTaskList(name: string, lists?: TaskListRecord[]): TaskListRecord;
+/** Caller must hold withTaskListsLock. */
+export declare function createTaskListLocked(name: string): TaskListRecord;
+/** Caller must hold withTaskListsLock. */
+export declare function renameTaskListLocked(currentName: string, nextName: string): TaskListRecord;
+/** Caller must hold withTaskListsLock. */
+export declare function deleteTaskListRecordLocked(listId: string): void;

package/dist/rooms-tasks/task-lists.js

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+export const DEFAULT_TASK_LIST_ID = 'default';
+export const TASK_LIST_NAME_MAX_CODE_POINTS = 64;
+const CREATED_AT = '1970-01-01T00:00:00.000Z';
+export class TaskListError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'TaskListError';
+    }
+}
+export const taskListsPath = () => join(stateRoot(), 'task-lists.json');
+export const taskListsLockPath = () => join(stateRoot(), 'task-lists.lock');
+export const withTaskListsLock = (fn) => withFileLock(taskListsLockPath(), fn);
+const defaultList = () => ({
+    list_id: DEFAULT_TASK_LIST_ID, name: 'default', built_in: true, created_at: CREATED_AT,
+});
+const compareNames = (a, b) => {
+    if (a.list_id === DEFAULT_TASK_LIST_ID)
+        return b.list_id === DEFAULT_TASK_LIST_ID ? 0 : -1;
+    if (b.list_id === DEFAULT_TASK_LIST_ID)
+        return 1;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : a.list_id.localeCompare(b.list_id);
+};
+export function normalizeTaskListName(input) {
+    if (typeof input !== 'string')
+        throw new TaskListError('invalid_name', 'list name must be a string');
+    const normalized = input.normalize('NFC');
+    if (normalized.trim() !== normalized || normalized.length === 0)
+        throw new TaskListError('invalid_name', 'list name must be non-empty with no leading or trailing whitespace');
+    if ([...normalized].length > TASK_LIST_NAME_MAX_CODE_POINTS)
+        throw new TaskListError('invalid_name', `list name must be at most ${TASK_LIST_NAME_MAX_CODE_POINTS} Unicode code points`);
+    if (/[\p{Cc}\p{Cf}\/\\]/u.test(normalized))
+        throw new TaskListError('invalid_name', 'list name contains a forbidden control, format, or path character');
+    return normalized;
+}
+export function readTaskLists() {
+    const path = taskListsPath();
+    if (!existsSync(path))
+        return [defaultList()];
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed.version !== 1 || !Array.isArray(parsed.lists))
+        throw new Error('invalid task list registry');
+    const custom = parsed.lists.filter(item => item.list_id !== DEFAULT_TASK_LIST_ID);
+    return [defaultList(), ...custom].sort(compareNames);
+}
+function writeTaskLists(lists) {
+    const custom = lists.filter(item => item.list_id !== DEFAULT_TASK_LIST_ID).sort(compareNames);
+    replaceFileAtomically(taskListsPath(), JSON.stringify({ version: 1, lists: custom }, null, 2) + '\n');
+}
+export function resolveTaskList(name, lists = readTaskLists()) {
+    const normalized = normalizeTaskListName(name);
+    const found = lists.find(item => item.name === normalized);
+    if (!found)
+        throw new TaskListError('list_not_found', `task list not found: ${normalized}`);
+    return found;
+}
+/** Caller must hold withTaskListsLock. */
+export function createTaskListLocked(name) {
+    const normalized = normalizeTaskListName(name);
+    if (normalized === 'default')
+        throw new TaskListError('reserved_name', "'default' is a reserved built-in list");
+    const lists = readTaskLists();
+    if (lists.some(item => item.name === normalized))
+        throw new TaskListError('duplicate_name', `task list already exists: ${normalized}`);
+    const record = {
+        list_id: `list_${randomUUID().replace(/-/g, '')}`, name: normalized,
+        built_in: false, created_at: new Date().toISOString(),
+    };
+    writeTaskLists([...lists, record]);
+    return record;
+}
+/** Caller must hold withTaskListsLock. */
+export function renameTaskListLocked(currentName, nextName) {
+    const lists = readTaskLists();
+    const current = resolveTaskList(currentName, lists);
+    if (current.built_in)
+        throw new TaskListError('default_immutable', "the 'default' list cannot be renamed");
+    const normalized = normalizeTaskListName(nextName);
+    if (normalized === 'default')
+        throw new TaskListError('reserved_name', "'default' is a reserved built-in list");
+    if (lists.some(item => item.list_id !== current.list_id && item.name === normalized))
+        throw new TaskListError('duplicate_name', `task list already exists: ${normalized}`);
+    const renamed = { ...current, name: normalized };
+    writeTaskLists(lists.map(item => item.list_id === current.list_id ? renamed : item));
+    return renamed;
+}
+/** Caller must hold withTaskListsLock. */
+export function deleteTaskListRecordLocked(listId) {
+    writeTaskLists(readTaskLists().filter(item => item.list_id !== listId));
+}

package/dist/rooms-tasks/task-state.d.ts

@@ -12,12 +12,15 @@ export interface CreateTaskInput {
     start?: boolean;
     no_room?: boolean;
     room_id?: string;
+    listId?: string;
 }
 export declare function createTask(input: CreateTaskInput): TaskRecord;
 export declare function getTask(id: string): TaskRecord;
 export declare function listTasks(filter?: {
     state?: TaskState | TaskState[];
+    listId?: string;
 }): TaskRecord[];
+export declare function moveTaskToList(id: string, listId: string): TaskRecord;
 export declare function findByIdempotencyKey(key: string): TaskRecord | undefined;
 export declare function startTask(id: string): TaskRecord;
 export declare function activateTask(id: string): TaskRecord;