Method handleTaskScope

packages/memos-core/src/viewer/server.ts:1672–1786

(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string)

  }

  private handleTaskScope(req: http.IncomingMessage, res: http.ServerResponse, urlPath: string): void {
    const taskId = urlPath.split("/")[3];
    this.readBody(req, async (body) => {
      try {
        const parsed = JSON.parse(body || "{}");
        const scope = parsed.scope as string;
        if (!["private", "local", "team"].includes(scope)) {
          return this.jsonResponse(res, { ok: false, error: "scope must be 'private', 'local', or 'team'" }, 400);
        }
        const task = this.store.getTask(taskId);
        if (!task) return this.jsonResponse(res, { ok: false, error: "task_not_found" }, 404);

        if (scope !== "private" && task.status !== "completed") {
          return this.jsonResponse(res, { ok: false, error: "only_completed_tasks_can_be_shared" }, 400);
        }

        const isLocalShared = task.owner === "public";
        const hubTask = this.getHubTaskForLocal(taskId);
        const taskShareUi = this.resolveTaskTeamShareForApi(taskId, hubTask);
        const isTeamShared = taskShareUi.hasHubLink;
        const currentScope = isTeamShared ? "team" : isLocalShared ? "local" : "private";

        if (scope === currentScope) {
          return this.jsonResponse(res, { ok: true, scope, changed: false });
        }

        let hubSynced = false;

        if (scope === "team") {
          if (!isTeamShared) {
            const chunks = this.store.getChunksByTask(taskId);
            const hubClient = await this.resolveHubClientAware();
            const refreshedTask = this.store.getTask(taskId)!;
            const response = await hubRequestJson(hubClient.hubUrl, hubClient.userToken, "/api/v1/hub/tasks/share", {
              method: "POST",
              body: JSON.stringify({
                task: { id: refreshedTask.id, sourceTaskId: refreshedTask.id, title: refreshedTask.title, summary: refreshedTask.summary, groupId: null, visibility: "public", createdAt: refreshedTask.startedAt ?? Date.now(), updatedAt: refreshedTask.updatedAt ?? Date.now() },
                chunks: chunks.map((c) => ({ id: c.id, hubTaskId: refreshedTask.id, sourceTaskId: refreshedTask.id, sourceChunkId: c.id, role: c.role, content: c.content, summary: c.summary, kind: c.kind, groupId: null, visibility: "public", createdAt: c.createdAt ?? Date.now() })),
              }),
            });
            const hubTaskId = String((response as any)?.taskId ?? "");
            if (this.sharingRole === "hub" && hubClient.userId) {
              const existing = this.store.getHubTaskBySource(hubClient.userId, taskId);
              this.store.upsertHubTask({
                id: hubTaskId || existing?.id || crypto.randomUUID(),
                sourceTaskId: taskId, sourceUserId: hubClient.userId, title: refreshedTask.title ?? "",
                summary: refreshedTask.summary ?? "", groupId: null, visibility: "public",
                createdAt: existing?.createdAt ?? Date.now(), updatedAt: Date.now(),
              });
            }
            const conn = this.store.getClientHubConnection();
            this.store.markTaskShared(taskId, hubTaskId, chunks.length, "public", null, conn?.hubInstanceId ?? "");
            hubSynced = true;
          }
          if (!isLocalShared) {
            const originalOwner = task.owner;
            const db = (this.store as any).db;
            db.prepare("INSERT INTO local_shared_tasks (task_id, hub_task_id, original_owner, hub_instance_id, shared_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(task_id) DO UPDATE SET original_owner = excluded.original_owner, hub_instance_id = excluded.hub_instance_id, shared_at = excluded.shared_at").run(taskId, "", originalOwner, "", Date.now());