feat: allow for digest-pinned composefiles and test-coverage fixes (#7)

* feat: allow for digest-pinned composefiles

* fix some coverage

* Add unit tests for digest helper functions per PR review feedback (#8)

* Initial plan

* Export helper functions and add comprehensive unit tests

Co-authored-by: Crow-Control <[email protected]>

---------

Co-authored-by: copilot-swe-agent[bot] <[email protected]>
Co-authored-by: Crow-Control <[email protected]>

* more fixes

* more fixes

* enforce coverage

---------

Co-authored-by: Copilot <[email protected]>

Author: Crow-Control

app/api/container.test.ts

@@ -1000,6 +1000,22 @@ describe('Container Router', () => {
       expect(res.json).toHaveBeenCalledWith(expect.any(Array));
     });
 
+    test('should associate trigger when configuration is missing', async () => {
+      const res = await callGetContainerTriggers({ id: 'c1' }, [
+        { type: 'slack', name: 'default' },
+      ]);
+
+      const triggers = getTriggersFromResponse(res);
+      expect(triggers).toHaveLength(1);
+      expect(triggers[0]).toEqual(
+        expect.objectContaining({
+          type: 'slack',
+          name: 'default',
+          configuration: {},
+        }),
+      );
+    });
+
     test('should filter triggers with triggerInclude', async () => {
       Trigger.parseIncludeOrIncludeTriggerString.mockReturnValue({ id: 'slack.default' });
       Trigger.doesReferenceMatchId.mockImplementation((ref, id) => ref === id);
@@ -1043,6 +1059,16 @@ describe('Container Router', () => {
       expect(getTriggersFromResponse(res)).toHaveLength(0);
     });
 
+    test('should keep non-docker local triggers for remote containers', async () => {
+      const res = await callGetContainerTriggers({ id: 'c1', agent: 'agent-1' }, [
+        { type: 'slack', name: 'default', configuration: {} },
+      ]);
+
+      const triggers = getTriggersFromResponse(res);
+      expect(triggers).toHaveLength(1);
+      expect(triggers[0].type).toBe('slack');
+    });
+
     test('should include triggers with matching include threshold', async () => {
       Trigger.parseIncludeOrIncludeTriggerString.mockReturnValue({
         id: 'slack.default',

app/api/trigger.test.ts

@@ -132,6 +132,27 @@ describe('Trigger Router', () => {
       expect(res.status).toHaveBeenCalledWith(200);
     });
 
+    test('should run trigger when mustTrigger is not a function', async () => {
+      const mockTrigger = {
+        mustTrigger: true,
+        trigger: vi.fn().mockResolvedValue(undefined),
+      };
+      registry.getState.mockReturnValue({
+        trigger: { 'slack.default': mockTrigger },
+      });
+
+      const req = {
+        params: { type: 'slack', name: 'default' },
+        body: { id: 'c1' },
+      };
+      const res = createResponse();
+
+      await runTrigger(req, res);
+
+      expect(mockTrigger.trigger).toHaveBeenCalledWith(expect.objectContaining({ id: 'c1' }));
+      expect(res.status).toHaveBeenCalledWith(200);
+    });
+
     test('should set default updateKind when missing', async () => {
       const mockTrigger = {
         mustTrigger: vi.fn().mockReturnValue(true),
@@ -240,6 +261,32 @@ describe('Trigger Router', () => {
         }),
       );
     });
+
+    test('should return 400 when trigger conditions are not met and container id is missing', async () => {
+      const mockTrigger = {
+        mustTrigger: vi.fn().mockReturnValue(false),
+        trigger: vi.fn(),
+      };
+      registry.getState.mockReturnValue({
+        trigger: { 'slack.default': mockTrigger },
+      });
+
+      const req = {
+        params: { type: 'slack', name: 'default' },
+        body: {},
+      };
+      const res = createResponse();
+
+      await runTrigger(req, res);
+
+      expect(mockTrigger.trigger).not.toHaveBeenCalled();
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          error: expect.stringContaining('Trigger conditions not met'),
+        }),
+      );
+    });
   });
 
   describe('runRemoteTrigger', () => {
@@ -323,6 +370,36 @@ describe('Trigger Router', () => {
       expect(res.status).toHaveBeenCalledWith(200);
     });
 
+    test('should run remote trigger when local proxy mustTrigger is not a function', async () => {
+      const mockAgentClient = {
+        runRemoteTrigger: vi.fn().mockResolvedValue(undefined),
+      };
+      agent.getAgent.mockReturnValue(mockAgentClient);
+      registry.getState.mockReturnValue({
+        trigger: {
+          'my-agent.slack.default': {
+            mustTrigger: true,
+          },
+        },
+      });
+
+      const handler = getRemoteTriggerHandler();
+      const req = {
+        params: { agent: 'my-agent', type: 'slack', name: 'default' },
+        body: { id: 'c1' },
+      };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(mockAgentClient.runRemoteTrigger).toHaveBeenCalledWith(
+        { id: 'c1' },
+        'slack',
+        'default',
+      );
+      expect(res.status).toHaveBeenCalledWith(200);
+    });
+
     test('should return 400 when remote trigger conditions are not met', async () => {
       const mockAgentClient = {
         runRemoteTrigger: vi.fn().mockResolvedValue(undefined),

app/api/trigger.ts

@@ -115,7 +115,7 @@ async function runRemoteTrigger(req, res) {
       !localProxyTrigger.mustTrigger(containerToTrigger)
     ) {
       log.warn(
-        `Remote trigger conditions not met (agent=${sanitizeLogParam(agentName)}, type=${sanitizeLogParam(triggerType)}, name=${sanitizeLogParam(triggerName)}, container=${sanitizeLogParam(containerToTrigger.id || 'unknown')})`,
+        `Remote trigger conditions not met (agent=${sanitizeLogParam(agentName)}, type=${sanitizeLogParam(triggerType)}, name=${sanitizeLogParam(triggerName)}, container=${sanitizeLogParam(containerToTrigger.id)})`,
       );
       res.status(400).json({
         error: `Trigger conditions not met for ${triggerType}.${triggerName} on agent ${agentName} (check include/exclude and requireinclude settings)`,