@ai-setting/roy-agent-core 1.7.88 → 1.7.89

package/dist/shared/@ai-setting/{roy-agent-core-7kvpc0w5.js → roy-agent-core-age3qseb.js}

@@ -1,7 +1,7 @@
 import {
   createCompatibleDatabase,
   init_sqlite_task_store
-} from "./roy-agent-core-6k8mb7zx.js";
+} from "./roy-agent-core-m66ysky0.js";
 import {
   createLogger,
   init_logger

package/dist/shared/@ai-setting/{roy-agent-core-an35dzbf.js → roy-agent-core-dvec4nn2.js}

@@ -2,7 +2,7 @@ import {
   createAutoTaskPlugin,
   createLayaDecisionPlugin,
   registerLayaCompletionTaskHook
-} from "./roy-agent-core-ra66sf50.js";
+} from "./roy-agent-core-k3h8t4q1.js";
 import {
   TaskHookPoints
 } from "./roy-agent-core-1pg0fepg.js";

package/dist/shared/@ai-setting/{roy-agent-core-ra66sf50.js → roy-agent-core-k3h8t4q1.js}

@@ -33,14 +33,14 @@ import {
   createLarkCardStateStore,
   getSharedLarkCardNotifier,
   humanizeValue
-} from "./roy-agent-core-shb1qsyg.js";
+} from "./roy-agent-core-0n1wwndq.js";
 import {
   RECENT_MESSAGE_LIMIT
 } from "./roy-agent-core-418zc9ha.js";
 import {
   createCompatibleDatabase,
   init_sqlite_task_store
-} from "./roy-agent-core-6k8mb7zx.js";
+} from "./roy-agent-core-m66ysky0.js";
 import {
   validateWorkflowDefinition
 } from "./roy-agent-core-rm7seqwb.js";
@@ -194,7 +194,8 @@ class TaskTagPlugin extends BasePlugin {
       const keywords = this.extractKeywords(currentTask);
       if (keywords.length === 0)
         return;
-      const similarTasks = await this.tagService?.findSimilarTasksByKeywords?.(keywords, {
+      const tagService = (this.taskComponent && typeof this.taskComponent.getTagService === "function" ? this.taskComponent.getTagService() : undefined) ?? this.tagService;
+      const similarTasks = await tagService?.findSimilarTasksByKeywords?.(keywords, {
         limit: 5,
         excludeTaskId: taskId
       }) ?? [];

package/dist/shared/@ai-setting/{roy-agent-core-6k8mb7zx.js → roy-agent-core-m66ysky0.js}

@@ -208,6 +208,37 @@ var init_005_convert_blob_description_to_text = __esm(() => {
   if (false) {}
 });
 
+// src/env/task/storage/migrations/006_add_task_owner.ts
+var exports_006_add_task_owner = {};
+__export(exports_006_add_task_owner, {
+  runMigration: () => runMigration6
+});
+function runMigration6(dbPath) {
+  logMigration(`[Migration 006] Starting migration for: ${dbPath}`);
+  const db = createCompatibleDatabase(dbPath);
+  try {
+    try {
+      db.run(`ALTER TABLE task ADD COLUMN owner TEXT`);
+      logMigration(`[Migration 006] Added owner column`);
+    } catch (e) {
+      if (e.message?.includes("duplicate column name")) {
+        logMigration(`[Migration 006] owner column already exists, skipping`);
+      } else {
+        throw e;
+      }
+    }
+    db.run(`CREATE INDEX IF NOT EXISTS idx_task_owner ON task(owner)`);
+    logMigration(`[Migration 006] Migration completed successfully`);
+  } finally {
+    db.close();
+  }
+}
+var init_006_add_task_owner = __esm(() => {
+  init_sqlite_task_store();
+  init_log_migration();
+  if (false) {}
+});
+
 // src/env/task/storage/sqlite-task-store.ts
 import { join } from "path";
 function getDatabaseClass() {
@@ -305,7 +336,8 @@ var init_sqlite_task_store = __esm(() => {
         due_date TEXT,
         tags TEXT,
         project_path TEXT NOT NULL DEFAULT 'unknown',
-        context TEXT NOT NULL DEFAULT '{}'
+        context TEXT NOT NULL DEFAULT '{}',
+        owner TEXT
       )
     `);
       this.db.run(`
@@ -375,6 +407,17 @@ var init_sqlite_task_store = __esm(() => {
         } catch (e) {
           logger.warn(`[Migration 005] Failed to run: ${e.message}`);
         }
+        try {
+          const { runMigration: runMigration006 } = (init_006_add_task_owner(), __toCommonJS(exports_006_add_task_owner));
+          runMigration006(this.dbPath);
+        } catch (e) {
+          logger.warn(`[Migration 006] Failed to run: ${e.message}`);
+        }
+      }
+      try {
+        this.db.run("CREATE INDEX IF NOT EXISTS idx_task_owner ON task(owner)");
+      } catch (e) {
+        logger.warn(`[TaskStore] idx_task_owner creation failed: ${e.message}`);
       }
       this.initialized = true;
       logger.info(`TaskStore initialized at ${this.dbPath}`);
@@ -385,10 +428,10 @@ var init_sqlite_task_store = __esm(() => {
       const stmt = this.db.prepare(`
       INSERT INTO task (title, description, priority, type, parent_task_id, 
         goals_and_expected_deliverables, due_date, tags, status, 
-        current_status, created_at, updated_at, project_path, context)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'todo', '', ?, ?, ?, ?)
+        current_status, created_at, updated_at, project_path, context, owner)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, 'todo', '', ?, ?, ?, ?, ?)
     `);
-      const result = stmt.run(options.title, options.description || "", options.priority || "medium", options.type || "normal", options.parent_task_id || null, options.goals_and_expected_deliverables || "", options.due_date || null, options.tags ? JSON.stringify(options.tags) : null, now, now, options.project_path, options.context);
+      const result = stmt.run(options.title, options.description || "", options.priority || "medium", options.type || "normal", options.parent_task_id || null, options.goals_and_expected_deliverables || "", options.due_date || null, options.tags ? JSON.stringify(options.tags) : null, now, now, options.project_path, options.context, options.owner || null);
       const task = await this.getTask(result.lastInsertRowid);
       if (task) {
         this.tasksCache.set(task.id, task);
@@ -468,6 +511,10 @@ var init_sqlite_task_store = __esm(() => {
         updates.push("parent_task_id = ?");
         values.push(options.parent_task_id);
       }
+      if (options.owner !== undefined) {
+        updates.push("owner = ?");
+        values.push(options.owner || null);
+      }
       if (updates.length === 0)
         return task;
       updates.push("updated_at = ?");
@@ -756,7 +803,8 @@ var init_sqlite_task_store = __esm(() => {
         due_date: row.due_date ? String(row.due_date) : undefined,
         tags: SQLiteTaskStore.parseTagsSafely(row.tags),
         project_path: String(row.project_path ?? "unknown"),
-        context: row.context
+        context: row.context,
+        owner: row.owner === undefined || row.owner === null ? null : String(row.owner)
       };
     }
     static parseTagsSafely(raw) {

package/dist/shared/@ai-setting/{roy-agent-core-yh68z1bg.js → roy-agent-core-m7d1t3db.js}

@@ -1,6 +1,6 @@
 import {
   builtInHandlers
-} from "./roy-agent-core-gr5h1dyr.js";
+} from "./roy-agent-core-4b38m749.js";
 import {
   appendAuditLog,
   checkSourceCountDrop,

package/dist/shared/@ai-setting/roy-agent-core-zhwcje5a.js

@@ -0,0 +1,352 @@
+import {
+  createLogger,
+  init_logger
+} from "./roy-agent-core-7f7t9wwp.js";
+
+// src/env/task/storage/remote-task-store.ts
+init_logger();
+
+class RemoteTaskStoreError extends Error {
+  endpoint;
+  cause;
+  constructor(message, endpoint, cause) {
+    super(message);
+    this.endpoint = endpoint;
+    this.cause = cause;
+    this.name = new.target.name;
+  }
+}
+
+class RemoteAuthError extends RemoteTaskStoreError {
+}
+
+class RemoteIdempotencyConflictError extends RemoteTaskStoreError {
+}
+
+class RemoteBatchBusyError extends RemoteTaskStoreError {
+}
+
+class RemoteProtocolError extends RemoteTaskStoreError {
+}
+var WRITE_METHODS = new Set([
+  "createTask",
+  "updateTask",
+  "deleteTask",
+  "createOperation",
+  "updateOperation",
+  "deleteOperation",
+  "createTag",
+  "deleteTag",
+  "addTagsToTask",
+  "removeTagsFromTask",
+  "updateTaskTags"
+]);
+var REMOTE_TASK_STORE_METHODS = [
+  "createTask",
+  "getTask",
+  "updateTask",
+  "deleteTask",
+  "listTasks",
+  "getTaskIdBySessionId",
+  "getTaskIdsBySessionId",
+  "createOperation",
+  "getOperation",
+  "updateOperation",
+  "deleteOperation",
+  "listOperations",
+  "listOperationsFresh",
+  "invalidateOperationsCache",
+  "createTag",
+  "getTag",
+  "getTagByName",
+  "listTags",
+  "searchTags",
+  "deleteTag",
+  "addTagsToTask",
+  "removeTagsFromTask",
+  "getTagsForTask",
+  "getTaskIdsByTags",
+  "updateTaskTags",
+  "searchTasksByKeywords",
+  "findSimilarTasksByKeywords",
+  "getTaskTree",
+  "getChildTasks",
+  "findSimilarTasks",
+  "searchTasks",
+  "findTasksByContextValue"
+];
+var REMOTE_PROTOCOL_MAJOR = 1;
+function trimTrailingNullish(args) {
+  let end = args.length;
+  while (end > 0) {
+    const v = args[end - 1];
+    if (v === null || v === undefined)
+      end -= 1;
+    else
+      break;
+  }
+  return end === args.length ? args : args.slice(0, end);
+}
+var defaultLog = createLogger("task-remote");
+
+class RemoteTaskStore {
+  endpoint;
+  authToken;
+  timeoutMs;
+  maxRetries;
+  retryBaseDelayMs;
+  fetchImpl;
+  log;
+  stats = { handshakes: 0, requests: 0, retries: 0 };
+  handshake;
+  closed = false;
+  constructor(options) {
+    if (!options?.endpoint) {
+      throw new Error("[RemoteTaskStore] endpoint is required (task.storage.endpoint)");
+    }
+    this.endpoint = options.endpoint.replace(/\/+$/, "");
+    this.authToken = options.authToken;
+    this.timeoutMs = options.timeoutMs ?? 5000;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.retryBaseDelayMs = options.retryBaseDelayMs ?? 200;
+    this.fetchImpl = options.fetchImpl ?? globalThis.fetch;
+    this.log = options.log ?? defaultLog;
+  }
+  getStats() {
+    return { ...this.stats };
+  }
+  ensureOpen() {
+    if (this.closed) {
+      throw new RemoteTaskStoreError(`RemoteTaskStore is closed (endpoint=${this.endpoint})`, this.endpoint);
+    }
+  }
+  async ensureHandshake() {
+    if (!this.handshake) {
+      this.handshake = this.doHandshake().catch((e) => {
+        this.handshake = undefined;
+        throw e;
+      });
+    }
+    return this.handshake;
+  }
+  async doHandshake() {
+    this.ensureOpen();
+    let res;
+    try {
+      res = await this.fetchWithTimeout(`${this.endpoint}/version`, { method: "GET" });
+    } catch (e) {
+      throw new RemoteTaskStoreError(`Cannot reach task-service at ${this.endpoint} (/version): ` + `${e instanceof Error ? e.message : String(e)}. ` + `Start it (systemctl --user start roy-task-service) or set task.storage.endpoint correctly. ` + `No local fallback is performed by design.`, this.endpoint, e);
+    }
+    if (!res.ok) {
+      throw new RemoteProtocolError(`task-service /version returned HTTP ${res.status} (endpoint=${this.endpoint})`, this.endpoint);
+    }
+    const body = await res.json().catch(() => ({}));
+    const major = body?.protocol?.major;
+    if (typeof major !== "number") {
+      throw new RemoteProtocolError(`task-service /version response has no protocol.major (endpoint=${this.endpoint})`, this.endpoint);
+    }
+    if (major !== REMOTE_PROTOCOL_MAJOR) {
+      throw new RemoteProtocolError(`Protocol mismatch: client speaks store-major ${REMOTE_PROTOCOL_MAJOR}, ` + `task-service speaks ${major} (endpoint=${this.endpoint}). Upgrade one side.`, this.endpoint);
+    }
+    this.stats.handshakes += 1;
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController;
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await this.fetchImpl(url, { ...init, signal: controller.signal });
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  isRetryableStatus(status) {
+    return status === 503 || status === 502 || status === 504 || status >= 500;
+  }
+  async call(method, rawArgs) {
+    this.ensureOpen();
+    await this.ensureHandshake();
+    const args = trimTrailingNullish(rawArgs);
+    const idempotencyKey = WRITE_METHODS.has(method) ? `${method}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}` : undefined;
+    let lastError;
+    for (let attempt = 0;attempt <= this.maxRetries; attempt++) {
+      if (attempt > 0) {
+        this.stats.retries += 1;
+        const backoff = this.retryBaseDelayMs * 2 ** (attempt - 1);
+        this.log.debug?.(`[RemoteTaskStore] retry ${attempt}/${this.maxRetries} ${method} in ${backoff}ms`);
+        await new Promise((r) => setTimeout(r, backoff));
+      }
+      const headers = { "content-type": "application/json" };
+      if (this.authToken)
+        headers.authorization = `Bearer ${this.authToken}`;
+      if (idempotencyKey)
+        headers["idempotency-key"] = idempotencyKey;
+      this.stats.requests += 1;
+      let res;
+      try {
+        res = await this.fetchWithTimeout(`${this.endpoint}/store/${method}`, {
+          method: "POST",
+          headers,
+          body: JSON.stringify({ args })
+        });
+      } catch (e) {
+        lastError = e;
+        if (attempt === this.maxRetries) {
+          throw new RemoteTaskStoreError(`task-service request failed: ${method} (endpoint=${this.endpoint}) after ` + `${attempt + 1} attempts: ${e instanceof Error ? e.message : String(e)}. ` + `No local fallback is performed by design.`, this.endpoint, e);
+        }
+        continue;
+      }
+      if (res.ok) {
+        const text = await res.text();
+        if (!text)
+          return;
+        try {
+          return JSON.parse(text);
+        } catch (e) {
+          throw new RemoteTaskStoreError(`task-service returned non-JSON for ${method} (endpoint=${this.endpoint})`, this.endpoint, e);
+        }
+      }
+      const body = await res.json().catch(() => null);
+      const code = body?.error?.code ?? "";
+      const detail = body?.error?.message ?? `HTTP ${res.status}`;
+      if (res.status === 401) {
+        throw new RemoteAuthError(`task-service rejected the request (401 ${code}): ${detail}. ` + `Check task.storage.authToken against the service's TASK_AUTH_TOKEN ` + `(endpoint=${this.endpoint}).`, this.endpoint);
+      }
+      if (res.status === 409 && code === "IDEMPOTENCY_CONFLICT") {
+        throw new RemoteIdempotencyConflictError(`task-service idempotency conflict for ${method}: ${detail} (endpoint=${this.endpoint})`, this.endpoint);
+      }
+      if (res.status === 404 && code === "METHOD_NOT_FOUND") {
+        throw new RemoteProtocolError(`task-service does not implement ${method}() — service is older than this client ` + `(endpoint=${this.endpoint}). deploy a newer task-service.`, this.endpoint);
+      }
+      if (res.status === 400) {
+        throw new RemoteTaskStoreError(`task-service rejected ${method} payload (400 ${code}): ${detail} (endpoint=${this.endpoint})`, this.endpoint);
+      }
+      if (res.status === 503 && code === "BUSY") {
+        lastError = new RemoteBatchBusyError(`sqlite backend busy for ${method}: a batch transaction holds the single shared ` + `connection; retried ${this.maxRetries} times without success (endpoint=${this.endpoint}). ` + `Retry after the batch completes.`, this.endpoint);
+        if (attempt === this.maxRetries)
+          throw lastError;
+        continue;
+      }
+      if (this.isRetryableStatus(res.status)) {
+        lastError = new RemoteTaskStoreError(`task-service error for ${method} (HTTP ${res.status} ${code}): ${detail} ` + `(endpoint=${this.endpoint})`, this.endpoint);
+        if (attempt === this.maxRetries)
+          throw lastError;
+        continue;
+      }
+      throw new RemoteTaskStoreError(`task-service rejected ${method} (HTTP ${res.status} ${code}): ${detail} ` + `(endpoint=${this.endpoint})`, this.endpoint);
+    }
+    throw new RemoteTaskStoreError(`task-service call ${method} exhausted retries (endpoint=${this.endpoint}): ` + `${lastError instanceof Error ? lastError.message : String(lastError)}`, this.endpoint, lastError);
+  }
+  createTask(options) {
+    return this.call("createTask", [options]);
+  }
+  async getTask(id) {
+    const task = await this.call("getTask", [id]);
+    return task ?? undefined;
+  }
+  async updateTask(id, options) {
+    const task = await this.call("updateTask", [id, options]);
+    return task ?? undefined;
+  }
+  deleteTask(id) {
+    return this.call("deleteTask", [id]);
+  }
+  listTasks(options) {
+    return this.call("listTasks", [options]);
+  }
+  async getTaskIdBySessionId(sessionId) {
+    const id = await this.call("getTaskIdBySessionId", [sessionId]);
+    return id ?? undefined;
+  }
+  getTaskIdsBySessionId(sessionId) {
+    return this.call("getTaskIdsBySessionId", [sessionId]);
+  }
+  createOperation(options) {
+    return this.call("createOperation", [options]);
+  }
+  async getOperation(id) {
+    const op = await this.call("getOperation", [id]);
+    return op ?? undefined;
+  }
+  async updateOperation(id, updates) {
+    const op = await this.call("updateOperation", [id, updates]);
+    return op ?? undefined;
+  }
+  deleteOperation(id) {
+    return this.call("deleteOperation", [id]);
+  }
+  listOperations(options) {
+    return this.call("listOperations", [options]);
+  }
+  listOperationsFresh(options) {
+    return this.call("listOperationsFresh", [options]);
+  }
+  invalidateOperationsCache(taskId) {
+    this.call("invalidateOperationsCache", [taskId]).catch((e) => {
+      this.log.warn?.(`[RemoteTaskStore] invalidateOperationsCache(${taskId}) failed: ` + `${e instanceof Error ? e.message : String(e)}`);
+    });
+  }
+  createTag(name) {
+    return this.call("createTag", [name]);
+  }
+  async getTag(id) {
+    const tag = await this.call("getTag", [id]);
+    return tag ?? undefined;
+  }
+  async getTagByName(name) {
+    const tag = await this.call("getTagByName", [name]);
+    return tag ?? undefined;
+  }
+  listTags(options) {
+    return this.call("listTags", [options]);
+  }
+  searchTags(options) {
+    return this.call("searchTags", [options]);
+  }
+  deleteTag(id) {
+    return this.call("deleteTag", [id]);
+  }
+  async addTagsToTask(taskId, tagIds) {
+    await this.call("addTagsToTask", [taskId, tagIds]);
+  }
+  async removeTagsFromTask(taskId, tagIds) {
+    await this.call("removeTagsFromTask", [taskId, tagIds]);
+  }
+  getTagsForTask(taskId) {
+    return this.call("getTagsForTask", [taskId]);
+  }
+  getTaskIdsByTags(tagNames) {
+    return this.call("getTaskIdsByTags", [tagNames]);
+  }
+  async updateTaskTags(taskId, tagNames) {
+    await this.call("updateTaskTags", [taskId, tagNames]);
+  }
+  searchTasksByKeywords(keywords, options) {
+    return this.call("searchTasksByKeywords", [keywords, options]);
+  }
+  findSimilarTasksByKeywords(keywords, options) {
+    return this.call("findSimilarTasksByKeywords", [keywords, options]);
+  }
+  getTaskTree(taskId, depth) {
+    return this.call("getTaskTree", [taskId, depth]);
+  }
+  getChildTasks(taskId, options) {
+    return this.call("getChildTasks", [taskId, options]);
+  }
+  findSimilarTasks(taskId, limit) {
+    return this.call("findSimilarTasks", [taskId, limit]);
+  }
+  searchTasks(query, limit) {
+    return this.call("searchTasks", [query, limit]);
+  }
+  findTasksByContextValue(value, limit) {
+    return this.call("findTasksByContextValue", [value, limit]);
+  }
+  close() {
+    this.closed = true;
+  }
+}
+function createRemoteTaskStore(options) {
+  return new RemoteTaskStore(options);
+}
+
+export { RemoteTaskStoreError, RemoteAuthError, RemoteIdempotencyConflictError, RemoteBatchBusyError, RemoteProtocolError, REMOTE_TASK_STORE_METHODS, REMOTE_PROTOCOL_MAJOR, RemoteTaskStore, createRemoteTaskStore };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ai-setting/roy-agent-core",
-  "version": "1.7.88",
+  "version": "1.7.89",
   "type": "module",
   "description": "Core SDK for roy-agent - Environment, Components, Tools, Sessions, Tasks",
   "main": "./dist/index.js",