@siftd/connect-agent 0.2.37 → 0.2.38

package/dist/tools/calendar.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Calendar + Todo Tools
+ *
+ * Safe, dedicated writers for Lia-managed JSON data used by /cal and /todo.
+ */
+import type { ToolResult } from './bash.js';
+type CalendarDef = {
+    id: string;
+    name: string;
+    color?: string;
+};
+type CalendarEventInput = {
+    id?: string;
+    title: string;
+    date?: string;
+    startTime?: string;
+    endTime?: string;
+    calendarId?: string;
+    notes?: string;
+};
+type TodoPriority = 'low' | 'medium' | 'high';
+type TodoSubtaskInput = {
+    id?: string;
+    title: string;
+    done?: boolean;
+    notes?: string;
+};
+type TodoItemInput = {
+    id?: string;
+    title: string;
+    done?: boolean;
+    due?: string;
+    priority?: TodoPriority;
+    notes?: string;
+    subtasks?: TodoSubtaskInput[];
+};
+export declare class CalendarTools {
+    private calendarPath;
+    private todoPath;
+    constructor();
+    upsertCalendarEvents(inputEvents: CalendarEventInput[], inputCalendars?: CalendarDef[]): ToolResult;
+    upsertTodoItems(inputItems: TodoItemInput[]): ToolResult;
+    private readCalendarPayload;
+    private normalizeCalendars;
+    private normalizeEvents;
+    private eventDedupeKey;
+    private readTodoPayload;
+    private normalizeTodoItems;
+}
+export {};

package/dist/tools/calendar.js

@@ -0,0 +1,233 @@
+/**
+ * Calendar + Todo Tools
+ *
+ * Safe, dedicated writers for Lia-managed JSON data used by /cal and /todo.
+ */
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { ensureLiaHub, getLiaHubPaths } from '../core/hub.js';
+import { createHash } from 'crypto';
+const DEFAULT_CALENDARS = [
+    { id: 'primary', name: 'Primary', color: '#8b5cf6' },
+    { id: 'work', name: 'Work', color: '#38bdf8' },
+    { id: 'research', name: 'Research', color: '#22c55e' },
+];
+function isDateKey(value) {
+    return /^\d{4}-\d{2}-\d{2}$/.test(value);
+}
+function isTimeKey(value) {
+    return /^\d{2}:\d{2}$/.test(value);
+}
+function parseIsoDate(value) {
+    const parsed = new Date(value);
+    if (Number.isNaN(parsed.getTime()))
+        return null;
+    return parsed;
+}
+function toDateKey(date) {
+    const year = date.getFullYear();
+    const month = `${date.getMonth() + 1}`.padStart(2, '0');
+    const day = `${date.getDate()}`.padStart(2, '0');
+    return `${year}-${month}-${day}`;
+}
+function toTimeKey(date) {
+    const hour = `${date.getHours()}`.padStart(2, '0');
+    const minute = `${date.getMinutes()}`.padStart(2, '0');
+    return `${hour}:${minute}`;
+}
+function normalizeTime(value) {
+    if (!value || typeof value !== 'string')
+        return {};
+    const trimmed = value.trim();
+    if (!trimmed)
+        return {};
+    if (isTimeKey(trimmed))
+        return { time: trimmed };
+    if (trimmed.includes('T')) {
+        const parsed = parseIsoDate(trimmed);
+        if (!parsed)
+            return {};
+        return { date: toDateKey(parsed), time: toTimeKey(parsed) };
+    }
+    return {};
+}
+function stableId(namespace, parts) {
+    const key = parts.filter(Boolean).join('|');
+    const hash = createHash('sha1').update(`${namespace}|${key}`).digest('hex').slice(0, 12);
+    return `${namespace}-${hash}`;
+}
+function safeParseJson(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+function writeFileAtomic(path, content) {
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, content, 'utf-8');
+    renameSync(tmp, path);
+}
+export class CalendarTools {
+    calendarPath;
+    todoPath;
+    constructor() {
+        const outputs = getLiaHubPaths().outputs;
+        this.calendarPath = join(outputs, '.lia', 'calendar.json');
+        this.todoPath = join(outputs, '.lia', 'todos.json');
+    }
+    upsertCalendarEvents(inputEvents, inputCalendars) {
+        try {
+            ensureLiaHub();
+            const stateDir = join(getLiaHubPaths().outputs, '.lia');
+            if (!existsSync(stateDir))
+                mkdirSync(stateDir, { recursive: true });
+            const existing = this.readCalendarPayload();
+            const calendars = this.normalizeCalendars(inputCalendars || existing.calendars);
+            const events = this.normalizeEvents(inputEvents, calendars, existing.events);
+            const payload = {
+                version: 1,
+                calendars,
+                events,
+            };
+            writeFileAtomic(this.calendarPath, JSON.stringify(payload, null, 2) + '\n');
+            return { success: true, output: `Calendar updated: ${inputEvents.length} upsert request(s), ${events.length} total event(s).` };
+        }
+        catch (error) {
+            return { success: false, output: '', error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    upsertTodoItems(inputItems) {
+        try {
+            ensureLiaHub();
+            const stateDir = join(getLiaHubPaths().outputs, '.lia');
+            if (!existsSync(stateDir))
+                mkdirSync(stateDir, { recursive: true });
+            const existing = this.readTodoPayload();
+            const items = this.normalizeTodoItems(inputItems, existing.items);
+            const payload = { version: 1, items };
+            writeFileAtomic(this.todoPath, JSON.stringify(payload, null, 2) + '\n');
+            return { success: true, output: `Todo updated: ${inputItems.length} upsert request(s), ${items.length} total item(s).` };
+        }
+        catch (error) {
+            return { success: false, output: '', error: error instanceof Error ? error.message : String(error) };
+        }
+    }
+    readCalendarPayload() {
+        if (!existsSync(this.calendarPath)) {
+            return { version: 1, calendars: DEFAULT_CALENDARS, events: [] };
+        }
+        const raw = readFileSync(this.calendarPath, 'utf-8');
+        const parsed = safeParseJson(raw);
+        const calendars = this.normalizeCalendars(parsed?.calendars);
+        const events = Array.isArray(parsed?.events) ? parsed?.events : [];
+        return { version: 1, calendars, events };
+    }
+    normalizeCalendars(calendars) {
+        if (!Array.isArray(calendars) || calendars.length === 0)
+            return DEFAULT_CALENDARS;
+        const normalized = calendars
+            .filter((cal) => Boolean(cal) && typeof cal.id === 'string' && typeof cal.name === 'string')
+            .map((cal, index) => ({
+            id: cal.id,
+            name: cal.name,
+            color: typeof cal.color === 'string' && cal.color ? cal.color : DEFAULT_CALENDARS[index % DEFAULT_CALENDARS.length].color,
+        }));
+        return normalized.length > 0 ? normalized : DEFAULT_CALENDARS;
+    }
+    normalizeEvents(inputEvents, calendars, existingEvents) {
+        const existingById = new Map(existingEvents.map((event) => [event.id, event]));
+        const seenKey = new Set(existingEvents.map((event) => this.eventDedupeKey(event)));
+        const fallbackCalendarId = calendars[0]?.id || 'primary';
+        for (const rawEvent of inputEvents) {
+            if (!rawEvent || typeof rawEvent.title !== 'string' || !rawEvent.title.trim())
+                continue;
+            const title = rawEvent.title.trim();
+            let date = typeof rawEvent.date === 'string' && isDateKey(rawEvent.date.trim()) ? rawEvent.date.trim() : undefined;
+            const startNorm = normalizeTime(rawEvent.startTime);
+            const endNorm = normalizeTime(rawEvent.endTime);
+            if (!date)
+                date = startNorm.date || endNorm.date;
+            if (!date)
+                date = toDateKey(new Date());
+            const startTime = startNorm.time || (typeof rawEvent.startTime === 'string' && isTimeKey(rawEvent.startTime.trim()) ? rawEvent.startTime.trim() : undefined);
+            const endTime = endNorm.time || (typeof rawEvent.endTime === 'string' && isTimeKey(rawEvent.endTime.trim()) ? rawEvent.endTime.trim() : undefined);
+            const calendarId = typeof rawEvent.calendarId === 'string' && rawEvent.calendarId.trim()
+                ? rawEvent.calendarId.trim()
+                : fallbackCalendarId;
+            const notes = typeof rawEvent.notes === 'string' && rawEvent.notes.trim() ? rawEvent.notes.trim() : undefined;
+            const id = typeof rawEvent.id === 'string' && rawEvent.id.trim()
+                ? rawEvent.id.trim()
+                : stableId('event', [title, date, startTime, endTime, calendarId]);
+            const event = { id, title, date, startTime, endTime, calendarId, notes };
+            const key = this.eventDedupeKey(event);
+            if (seenKey.has(key) && !existingById.has(id))
+                continue;
+            seenKey.add(key);
+            existingById.set(id, event);
+        }
+        return Array.from(existingById.values()).sort((a, b) => {
+            const dateCmp = a.date.localeCompare(b.date);
+            if (dateCmp !== 0)
+                return dateCmp;
+            return (a.startTime || '').localeCompare(b.startTime || '');
+        });
+    }
+    eventDedupeKey(event) {
+        return [event.title, event.date, event.startTime || '', event.endTime || '', event.calendarId].join('|').toLowerCase();
+    }
+    readTodoPayload() {
+        if (!existsSync(this.todoPath)) {
+            return { version: 1, items: [] };
+        }
+        const raw = readFileSync(this.todoPath, 'utf-8');
+        const parsed = safeParseJson(raw);
+        const items = Array.isArray(parsed?.items) ? parsed.items : [];
+        return { version: 1, items };
+    }
+    normalizeTodoItems(inputItems, existingItems) {
+        const existingById = new Map(existingItems.map((item) => [item.id, item]));
+        const seenKey = new Set(existingItems.map((item) => item.title.trim().toLowerCase()));
+        for (const rawItem of inputItems) {
+            if (!rawItem || typeof rawItem.title !== 'string' || !rawItem.title.trim())
+                continue;
+            const title = rawItem.title.trim();
+            const id = typeof rawItem.id === 'string' && rawItem.id.trim()
+                ? rawItem.id.trim()
+                : stableId('todo', [title, rawItem.due]);
+            const priority = rawItem.priority === 'low' || rawItem.priority === 'high' ? rawItem.priority : 'medium';
+            const due = typeof rawItem.due === 'string' && rawItem.due.trim() ? rawItem.due.trim() : undefined;
+            const notes = typeof rawItem.notes === 'string' && rawItem.notes.trim() ? rawItem.notes.trim() : undefined;
+            const incomingSubtasks = Array.isArray(rawItem.subtasks)
+                ? rawItem.subtasks
+                    .filter((subtask) => subtask && typeof subtask.title === 'string' && subtask.title.trim())
+                    .map((subtask, index) => ({
+                    id: typeof subtask.id === 'string' && subtask.id.trim()
+                        ? subtask.id.trim()
+                        : stableId('subtask', [id, subtask.title.trim(), String(index)]),
+                    title: subtask.title.trim(),
+                    done: Boolean(subtask.done),
+                    notes: typeof subtask.notes === 'string' && subtask.notes.trim() ? subtask.notes.trim() : undefined,
+                }))
+                : undefined;
+            const previous = existingById.get(id);
+            const subtasks = incomingSubtasks || previous?.subtasks;
+            let done = Boolean(rawItem.done);
+            if (incomingSubtasks && incomingSubtasks.length > 0) {
+                done = incomingSubtasks.every((subtask) => subtask.done);
+            }
+            else if (done && Array.isArray(previous?.subtasks) && previous.subtasks.length > 0) {
+                // Marking a parent done should also complete subtasks.
+                for (const subtask of previous.subtasks)
+                    subtask.done = true;
+            }
+            const key = title.toLowerCase();
+            if (seenKey.has(key) && !existingById.has(id))
+                continue;
+            seenKey.add(key);
+            existingById.set(id, { id, title, done, due, priority, notes, subtasks });
+        }
+        return Array.from(existingById.values());
+    }
+}

package/dist/tools/worker.d.ts

@@ -2,9 +2,10 @@
  * Worker Tools
  * Tools for spawning and managing Claude Code workers
  */
-import { GalleryCallback, GalleryWorker } from '../workers/manager.js';
+import { GalleryCallback, GalleryWorker, WorkerLogCallback } from '../workers/manager.js';
 import type { ToolResult } from './bash.js';
 export { GalleryCallback, GalleryWorker };
+export type { WorkerLogCallback };
 export declare class WorkerTools {
     private manager;
     constructor(workspaceDir: string);
@@ -12,6 +13,10 @@ export declare class WorkerTools {
      * Set callback for gallery updates (worker assets for UI)
      */
     setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Set callback for worker log streaming (stdout/stderr)
+     */
+    setLogCallback(callback: WorkerLogCallback | null): void;
     /**
      * Get gallery workers with assets
      */

package/dist/tools/worker.js

@@ -14,6 +14,12 @@ export class WorkerTools {
     setGalleryCallback(callback) {
         this.manager.setGalleryCallback(callback);
     }
+    /**
+     * Set callback for worker log streaming (stdout/stderr)
+     */
+    setLogCallback(callback) {
+        this.manager.setLogCallback(callback);
+    }
     /**
      * Get gallery workers with assets
      */

package/dist/workers/manager.d.ts

@@ -9,16 +9,23 @@ export interface GalleryWorker {
     status: 'running' | 'completed' | 'failed';
     assets: WorkerAsset[];
 }
+export type WorkerLogCallback = (workerId: string, line: string, stream: 'stdout' | 'stderr') => void;
 export type GalleryCallback = (workers: GalleryWorker[]) => void;
 export declare class WorkerManager {
     private config;
     private activeWorkers;
     private galleryCallback;
+    private workerLogCallback;
     constructor(workspaceDir: string, configOverrides?: Partial<WorkerConfig>);
     /**
      * Set callback for gallery updates (worker assets for UI)
      */
     setGalleryCallback(callback: GalleryCallback | null): void;
+    /**
+     * Set callback for worker log streaming (stdout/stderr)
+     */
+    setLogCallback(callback: WorkerLogCallback | null): void;
+    private emitWorkerLog;
     /**
      * Get gallery workers with assets for UI
      */

package/dist/workers/manager.js

@@ -52,6 +52,7 @@ export class WorkerManager {
     config;
     activeWorkers = new Map();
     galleryCallback = null;
+    workerLogCallback = null;
     constructor(workspaceDir, configOverrides) {
         this.config = {
             ...DEFAULT_WORKER_CONFIG,
@@ -69,6 +70,23 @@ export class WorkerManager {
     setGalleryCallback(callback) {
         this.galleryCallback = callback;
     }
+    /**
+     * Set callback for worker log streaming (stdout/stderr)
+     */
+    setLogCallback(callback) {
+        this.workerLogCallback = callback;
+    }
+    emitWorkerLog(workerId, chunk, stream) {
+        if (!this.workerLogCallback)
+            return;
+        const lines = chunk.split(/\r?\n/);
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            this.workerLogCallback(workerId, trimmed.slice(0, 500), stream);
+        }
+    }
     /**
      * Get gallery workers with assets for UI
      */
@@ -174,10 +192,18 @@ This ensures nothing is lost even if your output gets truncated.`;
                 GH_TOKEN: process.env.GH_TOKEN,
                 GITHUB_TOKEN: process.env.GITHUB_TOKEN
             };
+            // Ensure worker uses the user's workspace as HOME so ~/Lia-Hub maps correctly
+            spawnEnv = {
+                ...spawnEnv,
+                HOME: workspace,
+                LIA_WORKSPACE: workspace,
+                USER: spawnEnv.USER || 'lia',
+                LOGNAME: spawnEnv.LOGNAME || 'lia'
+            };
             if (isRoot) {
-                // When running as root, use runuser to switch to 'lia' user while preserving env
-                // runuser -l creates a login shell but -m preserves the environment
-                shellCmd = `runuser -u lia -- /bin/bash -l -c "${claudeCmd.replace(/"/g, '\\"')}"`;
+                // When running as root, use runuser to switch to 'lia' user while preserving env (HOME)
+                // runuser -m preserves env; -l ensures PATH resolution for nvm/claude
+                shellCmd = `runuser -u lia -m -- /bin/bash -l -c "${claudeCmd.replace(/"/g, '\\"')}"`;
             }
             else {
                 shellCmd = claudeCmd;
@@ -198,10 +224,14 @@ This ensures nothing is lost even if your output gets truncated.`;
             let stdout = '';
             let stderr = '';
             child.stdout?.on('data', (data) => {
-                stdout += data.toString();
+                const text = data.toString();
+                stdout += text;
+                this.emitWorkerLog(jobId, text, 'stdout');
             });
             child.stderr?.on('data', (data) => {
-                stderr += data.toString();
+                const text = data.toString();
+                stderr += text;
+                this.emitWorkerLog(jobId, text, 'stderr');
             });
             // Set up timeout
             const timeoutHandle = setTimeout(() => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@siftd/connect-agent",
-  "version": "0.2.37",
+  "version": "0.2.38",
   "description": "Master orchestrator agent - control Claude Code remotely via web",
   "type": "module",
   "main": "dist/index.js",