[Node web] bump all npm dependencies to latest compatible versions

- All patch/minor bumps applied (tanstack router/query, radix-ui, tailwind, zod, etc.)
- Major bumps: lucide-react 0.x→1.x, typescript 5→6, vite 7→8, @hey-api/openapi-ts 0.73→0.97
- Add ignoreDeprecations: "6.0" to tsconfig.json (baseUrl deprecation in TS6, still required for paths)
- Fix 2 audit vulnerabilities (follow-redirects, picomatch) via npm audit fix
- All 298 tests pass, tsc clean

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: Herklos

packages/node/octobot_node/scheduler/api.py

@@ -66,7 +66,7 @@ def _filter_by_wallet(statuses: typing.Any, wallet_address: str) -> list:
     kept = []
     for s in statuses:
         task = workflows_util.get_input_task(s)
-        if task is not None and task.wallet_address == wallet_address:
+        if task is None or not task.wallet_address or task.wallet_address == wallet_address:
             kept.append(s)
     return kept
 

packages/node/octobot_node/scheduler/scheduler.py

@@ -149,7 +149,12 @@ async def get_pending_tasks(self, wallet_address: typing.Optional[str] = None) -
             for pending_workflow_status in pending_workflow_statuses or []:
                 try:
                     task = workflows_util.get_input_task(pending_workflow_status)
-                    if wallet_address is not None and (task is None or task.wallet_address != wallet_address):
+                    if (
+                        wallet_address is not None
+                        and task is not None
+                        and task.wallet_address
+                        and task.wallet_address != wallet_address
+                    ):
                         continue
                     if reader := workflows_util.get_automation_state_reader(pending_workflow_status):
                         next_step = ", ".join([
@@ -201,16 +206,37 @@ async def get_results(self, wallet_address: typing.Optional[str] = None) -> list
         try:
             completed_workflow_statuses = await self.INSTANCE.list_workflows_async(status=[
                 dbos.WorkflowStatusString.SUCCESS.value, dbos.WorkflowStatusString.ERROR.value
-            ], load_output=False)
+            ], load_output=True)
             for completed_workflow_status in completed_workflow_statuses or []:
                 try:
                     task = workflows_util.get_input_task(completed_workflow_status)
-                    if wallet_address is not None and (task is None or task.wallet_address != wallet_address):
+                    if (
+                        wallet_address is not None
+                        and task is not None
+                        and task.wallet_address
+                        and task.wallet_address != wallet_address
+                    ):
                         continue
                     if completed_workflow_status.status == dbos.WorkflowStatusString.SUCCESS.value:
-                        status = octobot_node.models.TaskStatus.COMPLETED
-                        description = "Completed"
-                        error = None
+                        output_error = None
+                        if completed_workflow_status.output:
+                            try:
+                                output = workflow_params.AutomationWorkflowOutput.from_dict(
+                                    json.loads(completed_workflow_status.output)
+                                )
+                                output_error = output.error
+                            except Exception as parse_err:
+                                self.logger.warning(
+                                    f"Failed to parse output for workflow {completed_workflow_status.workflow_id}: {parse_err}"
+                                )
+                        if output_error:
+                            status = octobot_node.models.TaskStatus.FAILED
+                            description = "ERROR"
+                            error = output_error
+                        else:
+                            status = octobot_node.models.TaskStatus.COMPLETED
+                            description = "Completed"
+                            error = None
                     else:
                         status = octobot_node.models.TaskStatus.FAILED
                         description = "ERROR"

packages/node/tests/scheduler/test_api.py

@@ -192,6 +192,41 @@ def list_side_effect(status=None, **kwargs):
         assert result["results"] == 3    # only 0xmine
         mock_crypto.assert_not_called()
 
+    @pytest.mark.asyncio
+    async def test_get_task_metrics_counts_legacy_and_unparseable_for_every_wallet(self) -> None:
+        """Regression: tasks with no wallet_address (legacy) or unparseable input must count
+        toward every wallet's metrics — never silently dropped (that hid all errored tasks).
+        """
+        import dbos
+
+        legacy_wf = _make_wf_status("dddddddd-dddd-dddd-dddd-ddddddddddd1",
+                                     dbos.WorkflowStatusString.SUCCESS.value, wallet_address=None)
+        unparseable_wf = mock.Mock()
+        unparseable_wf.workflow_id = "dddddddd-dddd-dddd-dddd-ddddddddddd2"
+        unparseable_wf.status = dbos.WorkflowStatusString.SUCCESS.value
+        unparseable_wf.input = {"args": [], "kwargs": {}}  # nothing parseable
+        unparseable_wf.created_at = None
+        unparseable_wf.updated_at = None
+        other_wf = _make_wf_status("dddddddd-dddd-dddd-dddd-ddddddddddd3",
+                                    dbos.WorkflowStatusString.SUCCESS.value, wallet_address="0xother")
+
+        mock_instance = mock.AsyncMock()
+
+        def list_side_effect(status=None, **kwargs):
+            if dbos.WorkflowStatusString.PENDING.value in (status or []):
+                return []
+            return [legacy_wf, unparseable_wf, other_wf]
+
+        mock_instance.list_workflows_async = mock.AsyncMock(side_effect=list_side_effect)
+        mock_scheduler = mock.Mock()
+        mock_scheduler.INSTANCE = mock_instance
+
+        with mock.patch("octobot_node.scheduler.SCHEDULER", mock_scheduler):
+            result = await get_task_metrics(wallet_address="0xmine")
+
+        # legacy + unparseable kept (2), explicit other_wallet dropped (1)
+        assert result["results"] == 2
+
     @pytest.mark.asyncio
     async def test_get_task_metrics_uninitialized_scheduler(self) -> None:
         """Test task metrics when scheduler is not initialized."""

packages/node/tests/scheduler/test_scheduler.py

@@ -108,8 +108,6 @@ async def test_get_results_returns_empty_result_no_crypto(self):
         assert executions[0].result == ""
         assert executions[0].result_metadata == ""
         mock_crypto.assert_not_called()
-        for call in mock_instance.list_workflows_async.call_args_list:
-            assert call.kwargs.get("load_output") is False
 
     @pytest.mark.asyncio
     async def test_get_results_sets_is_encrypted_from_content_metadata(self):
@@ -200,6 +198,133 @@ async def test_get_results_dbos_error_no_exception_fallback(self):
         assert len(executions) == 1
         assert executions[0].error  # fallback string must be truthy
 
+    @pytest.mark.asyncio
+    async def test_get_results_success_with_output_error_marks_failed(self):
+        """DBOS SUCCESS workflow whose output.error is set must surface as FAILED."""
+        task = octobot_node.models.Task(
+            id="eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee",
+            name="business-failed-task",
+            content=None,
+            type="execute_actions",
+        )
+        output = params.AutomationWorkflowOutput(error="Trade rejected by exchange")
+        inputs = params.AutomationWorkflowInputs(task=task)
+        ws = mock.Mock(spec=dbos.WorkflowStatus)
+        ws.workflow_id = "eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee"
+        ws.name = "business-failed-task"
+        ws.status = dbos.WorkflowStatusString.SUCCESS.value
+        ws.output = json.dumps(output.to_dict())
+        ws.error = None
+        ws.input = {"args": [inputs.to_dict()], "kwargs": {}}
+        ws.created_at = None
+        ws.updated_at = None
+
+        sched, mock_instance = _make_scheduler_with_mock_instance()
+        mock_instance.list_workflows_async = mock.AsyncMock(return_value=[ws])
+
+        executions = await sched.get_results()
+
+        assert len(executions) == 1
+        assert executions[0].status == octobot_node.models.TaskStatus.FAILED
+        assert executions[0].error == "Trade rejected by exchange"
+
+    @pytest.mark.asyncio
+    async def test_get_results_success_with_malformed_output_falls_back_to_completed(self):
+        """SUCCESS workflow with unparseable output JSON must NOT crash and must default to COMPLETED.
+
+        Regression guard: a parse exception inside the SUCCESS branch must not bubble up
+        and must not flip the task to FAILED — the workflow ran fine at DBOS level.
+        """
+        task = octobot_node.models.Task(
+            id="ffffffff-ffff-ffff-ffff-ffffffffffff",
+            name="malformed-output-task",
+            content=None,
+            type="execute_actions",
+        )
+        inputs = params.AutomationWorkflowInputs(task=task)
+        ws = mock.Mock(spec=dbos.WorkflowStatus)
+        ws.workflow_id = "ffffffff-ffff-ffff-ffff-ffffffffffff"
+        ws.name = "malformed-output-task"
+        ws.status = dbos.WorkflowStatusString.SUCCESS.value
+        ws.output = "{not valid json"
+        ws.error = None
+        ws.input = {"args": [inputs.to_dict()], "kwargs": {}}
+        ws.created_at = None
+        ws.updated_at = None
+
+        sched, mock_instance = _make_scheduler_with_mock_instance()
+        mock_instance.list_workflows_async = mock.AsyncMock(return_value=[ws])
+
+        executions = await sched.get_results()
+
+        assert len(executions) == 1
+        assert executions[0].status == octobot_node.models.TaskStatus.COMPLETED
+        assert executions[0].error is None
+
+    @pytest.mark.asyncio
+    async def test_get_results_wallet_filter_keeps_legacy_task_without_wallet_address(self):
+        """Regression: tasks created before the multi-wallet refactor have task.wallet_address=None.
+        They must remain visible to any caller — never dropped by the wallet filter.
+        """
+        legacy_task = octobot_node.models.Task(
+            id="aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa",
+            name="legacy-task",
+            content=None,
+            type="execute_actions",
+            wallet_address=None,  # pre-multi-tenant: no wallet attached
+        )
+        ws = _build_mock_workflow_status(legacy_task, None, None, workflow_id=legacy_task.id)
+
+        sched, mock_instance = _make_scheduler_with_mock_instance()
+        mock_instance.list_workflows_async = mock.AsyncMock(return_value=[ws])
+
+        executions = await sched.get_results(wallet_address="0xcaller")
+
+        assert len(executions) == 1
+        assert executions[0].id == legacy_task.id
+
+    @pytest.mark.asyncio
+    async def test_get_results_wallet_filter_keeps_workflow_with_unparseable_input(self):
+        """Regression: a crashed workflow may have unparseable input → get_input_task returns None.
+        Must remain visible — silently dropping is what hid all errored tasks before.
+        """
+        ws = mock.Mock(spec=dbos.WorkflowStatus)
+        ws.workflow_id = "bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+        ws.name = "crashed-task"
+        ws.status = dbos.WorkflowStatusString.ERROR.value
+        ws.output = None
+        ws.error = RuntimeError("crashed before input was persisted")
+        ws.input = {"args": [], "kwargs": {}}  # nothing parseable
+        ws.created_at = None
+        ws.updated_at = None
+
+        sched, mock_instance = _make_scheduler_with_mock_instance()
+        mock_instance.list_workflows_async = mock.AsyncMock(return_value=[ws])
+
+        executions = await sched.get_results(wallet_address="0xcaller")
+
+        assert len(executions) == 1
+        assert executions[0].status == octobot_node.models.TaskStatus.FAILED
+
+    @pytest.mark.asyncio
+    async def test_get_results_wallet_filter_drops_task_with_explicit_other_wallet(self):
+        """Sanity check that the filter still drops tasks explicitly owned by a different wallet."""
+        other_task = octobot_node.models.Task(
+            id="cccccccc-cccc-cccc-cccc-cccccccccccc",
+            name="other-task",
+            content=None,
+            type="execute_actions",
+            wallet_address="0xother",
+        )
+        ws = _build_mock_workflow_status(other_task, None, None, workflow_id=other_task.id)
+
+        sched, mock_instance = _make_scheduler_with_mock_instance()
+        mock_instance.list_workflows_async = mock.AsyncMock(return_value=[ws])
+
+        executions = await sched.get_results(wallet_address="0xcaller")
+
+        assert executions == []
+
 
 class TestGetWorkflowsExportResults: