@agentteams/runner 0.0.108 → 0.0.110

package/dist/handlers/trigger-handler.test.js

@@ -2,7 +2,7 @@ import assert from 'node:assert/strict';
 import test, { mock } from 'node:test';
 import { execFileSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { mkdtemp, rm, stat } from 'node:fs/promises';
+import { mkdir, mkdtemp, rm, stat, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { logger } from '../logger.js';
@@ -75,8 +75,8 @@ test('createTriggerHandler runs the runner, reports history, and marks success',
     const runner = {
         run: async (input) => {
             runnerInputs.push({ prompt: input.prompt, authPath: input.authPath });
-            input.onStdoutChunk?.('stdout');
-            input.onStderrChunk?.('stderr');
+            input.onStdoutChunk?.('stdout', 'TEXT');
+            input.onStderrChunk?.('stderr', 'STDERR');
             return { exitCode: 0 };
         },
     };
@@ -96,13 +96,14 @@ test('createTriggerHandler runs the runner, reports history, and marks success',
             discoveredAuthPaths.push(authPath);
         },
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => runner,
         createLogReporter: () => ({
             start: () => {
                 logEntries.push({ level: 'START', message: 'started' });
             },
-            append: (level, message) => {
-                logEntries.push({ level, message });
+            append: (level, message, category, toolName) => {
+                logEntries.push({ level, message, category, toolName });
             },
             stop: async () => {
                 logEntries.push({ level: 'STOP', message: 'stopped' });
@@ -118,8 +119,8 @@ test('createTriggerHandler runs the runner, reports history, and marks success',
     assert.deepEqual(discoveredAuthPaths, ['/auth/path']);
     assert.equal(runnerInputs.length, 1);
     assert.equal(runnerInputs[0]?.prompt, 'API runner prompt\n- History path: /auth/path/.agentteams/runner/history/trigger-1.md\n- Previous history path: /auth/path/.agentteams/runner/history/parent-1.md');
-    assert.equal(logEntries.some((entry) => entry.level === 'INFO' && entry.message.includes('stdout')), true);
-    assert.equal(logEntries.some((entry) => entry.level === 'WARN' && entry.message.includes('stderr')), true);
+    assert.equal(logEntries.some((entry) => entry.level === 'INFO' && entry.category === 'TEXT' && entry.message.includes('stdout')), true);
+    assert.equal(logEntries.some((entry) => entry.level === 'WARN' && entry.category === 'STDERR' && entry.message.includes('stderr')), true);
     assert.deepEqual(clientCalls.map((entry) => entry.method), ['fetchTriggerRuntime', 'isTriggerCancelRequested', 'updateTriggerHistory', 'updateTriggerStatus']);
     assert.deepEqual(clientCalls.at(-1)?.args, ['trigger-1', 'DONE', undefined]);
 });
@@ -325,6 +326,7 @@ test('createTriggerHandler preserves the local history file and still marks succ
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0, outputText: '{"type":"result"}' }),
         }),
@@ -377,6 +379,7 @@ test('createTriggerHandler flags NEEDS_REVIEW when the runner exits 0 without wr
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0, outputText: 'The final summary.' }),
         }),
@@ -433,6 +436,7 @@ test('createTriggerHandler strips a UTF-8 BOM before reporting history to the da
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0 }),
         }),
@@ -482,6 +486,7 @@ test('createTriggerHandler keeps history unchanged when the Questions for User s
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0 }),
         }),
@@ -528,6 +533,7 @@ test('createTriggerHandler restores parent history from server-side coaction con
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ prompt: input.prompt, authPath: input.authPath });
@@ -586,6 +592,7 @@ test('createTriggerHandler strips a UTF-8 BOM before restoring parent history fr
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0 }),
         }),
@@ -635,6 +642,7 @@ test('createTriggerHandler overwrites existing parent history with server cumula
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0 }),
         }),
@@ -685,6 +693,7 @@ test('createTriggerHandler reports runner failures and falls back to last output
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 1, lastOutput: 'last output' }),
         }),
@@ -727,6 +736,7 @@ test('createTriggerHandler reports the explicit runner error before last output'
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 1,
@@ -786,6 +796,7 @@ test('createTriggerHandler fails without running the runner when worktree creati
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ authPath: input.authPath });
@@ -851,6 +862,7 @@ test('createTriggerHandler fails without running the runner when worktree authPa
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ authPath: input.authPath });
@@ -918,6 +930,7 @@ test('createTriggerHandler resolves a member repo via remoteUrl when worktree au
             discoveredAuthPaths.push(authPath);
         },
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ authPath: input.authPath });
@@ -996,6 +1009,7 @@ test('createTriggerHandler fails without running the runner when member repo res
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ authPath: input.authPath });
@@ -1075,6 +1089,7 @@ test('worktrees created via member repo resolution are removed by the poller lif
                 discoveredAuthPaths.push(authPath);
             },
         }, {
+            pathExists: () => true,
             createRunnerFactory: () => () => ({
                 run: async () => ({ exitCode: 0 }),
             }),
@@ -1195,6 +1210,7 @@ test('createTriggerHandler downgrades an idle-timeout to NEEDS_REVIEW when a his
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 1,
@@ -1244,6 +1260,7 @@ test('createTriggerHandler keeps an idle-timeout as FAILED when no history file
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             // idle 타임아웃이지만 히스토리 파일도, stdout 폴백도 없으면 작업 완료를 보장할 수 없어 FAILED 유지.
             run: async () => ({
@@ -1293,6 +1310,7 @@ test('createTriggerHandler stores stdout as fallback history when the runner omi
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 0,
@@ -1351,6 +1369,7 @@ test('createTriggerHandler truncates long agent output in fallback history', asy
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 0,
@@ -1406,6 +1425,7 @@ test('createTriggerHandler preserves fallback agent output within history limit'
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({
                 exitCode: 0,
@@ -1461,6 +1481,7 @@ test('createTriggerHandler cancels the runner when the server reports a cancel r
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async ({ signal }) => {
                 await new Promise((resolve) => {
@@ -1537,6 +1558,10 @@ test('createTriggerHandler marks the trigger as failed when runtime loading thro
 // ---------------------------------------------------------------------------
 const withTempDir = async (run) => {
     const dir = await mkdtemp(join(tmpdir(), 'trigger-handler-hook-test-'));
+    // 실행 전 작업 디렉터리 검증(checkRunnerWorkingDirectory)이 프로젝트 마커를 요구하므로,
+    // 임시 워크스페이스도 실제 러너 워크스페이스와 같은 마커(트리거와 같은 projectId)를 갖춘다.
+    await mkdir(join(dir, '.agentteams'), { recursive: true });
+    await writeFile(join(dir, '.agentteams', 'config.json'), `${JSON.stringify({ projectId: runtime.projectId })}\n`, 'utf8');
     try {
         await run(dir);
     }
@@ -1782,7 +1807,7 @@ test('createTriggerHandler logs but does not throw when attachment cleanup fails
         assert.deepEqual(cleanupCalls, [join(dir, '.agentteams', 'runner', 'attachments', 'trigger-1')]);
     });
 });
-test('createTriggerHandler fails before runner execution when attachments have no runner workspace', async () => {
+test('createTriggerHandler fails before runner execution when the runner workspace is not configured', async () => {
     const clientCalls = [];
     let runnerCalled = false;
     const client = {
@@ -1836,11 +1861,11 @@ test('createTriggerHandler fails before runner execution when attachments have n
     });
     await handler({ ...trigger, parentTriggerId: null });
     assert.equal(runnerCalled, false);
-    assert.deepEqual(clientCalls.at(-1)?.args, [
-        'trigger-1',
-        'FAILED',
-        'Cannot deliver attachments because runner workspace path is not configured.',
-    ]);
+    const [triggerId, status, message] = (clientCalls.at(-1)?.args ?? []);
+    assert.equal(triggerId, 'trigger-1');
+    assert.equal(status, 'FAILED');
+    // 워크스페이스 경로가 없는 실행은 첨부 전달 단계보다 앞선 작업 디렉터리 검증에서 끝난다.
+    assert.match(message, /Runner workspace path is not configured/);
 });
 test('createTriggerHandler does not append history or convention text to the API prompt', async () => {
     await withTempDir(async (dir) => {
@@ -1924,6 +1949,7 @@ test('createTriggerHandler surfaces a user-visible warning when the runner ignor
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async (input) => {
                 runnerInputs.push({ model: input.model, fastMode: input.fastMode });
@@ -1973,6 +1999,7 @@ test('createTriggerHandler does not warn when the runner supports the requested
         },
         client: client,
     }, {
+        pathExists: () => true,
         createRunnerFactory: () => () => ({
             run: async () => ({ exitCode: 0 }),
         }),
@@ -1993,4 +2020,260 @@ test('createTriggerHandler does not warn when the runner supports the requested
     const unsupportedWarnings = logEntries.filter((entry) => entry.level === 'WARN' && /is not supported by runner/.test(entry.message));
     assert.deepEqual(unsupportedWarnings, []);
 });
+// ---------------------------------------------------------------------------
+// Working directory pre-flight tests
+// ---------------------------------------------------------------------------
+test('createTriggerHandler fails without creating the workspace when authPath is missing on this runner', async () => {
+    await withTempDir(async (dir) => {
+        const missingAuthPath = join(dir, 'not-on-this-machine');
+        const clientCalls = [];
+        const logEntries = [];
+        let runnerCalled = false;
+        const client = {
+            fetchTriggerRuntime: async () => ({ ...runtime, authPath: missingAuthPath }),
+            isTriggerCancelRequested: async () => false,
+            updateTriggerHistory: async (...args) => {
+                clientCalls.push({ method: 'updateTriggerHistory', args });
+            },
+            updateTriggerStatus: async (...args) => {
+                clientCalls.push({ method: 'updateTriggerStatus', args });
+            },
+        };
+        const handler = createTriggerHandler({
+            config: {
+                daemonToken: 'daemon-token',
+                apiUrl: 'https://api.example',
+                pollingIntervalMs: 5000,
+                maxPollingIntervalMs: 120_000,
+                timeoutMs: 1500,
+                idleTimeoutMs: 500,
+                runnerCmd: 'opencode',
+                preventSleepWhileBusy: false,
+            },
+            client: client,
+        }, {
+            createRunnerFactory: () => () => ({
+                run: async () => {
+                    runnerCalled = true;
+                    return { exitCode: 0 };
+                },
+            }),
+            createLogReporter: () => ({
+                start: () => undefined,
+                append: (level, message) => {
+                    logEntries.push({ level, message });
+                },
+                stop: async () => undefined,
+            }),
+            readHistoryFile: async () => '',
+        });
+        await handler({ ...trigger, parentTriggerId: null });
+        assert.equal(runnerCalled, false);
+        assert.equal(existsSync(missingAuthPath), false);
+        const statusCall = clientCalls.filter((call) => call.method === 'updateTriggerStatus').at(-1);
+        assert.equal(statusCall?.args[1], 'FAILED');
+        assert.match(String(statusCall?.args[2]), /does not exist on this runner/);
+        assert.match(String(statusCall?.args[2]), /machine where this agent was registered/);
+        assert.equal(logEntries.some((entry) => entry.level === 'ERROR' && /does not exist on this runner/.test(entry.message)), true);
+    });
+});
+test('createTriggerHandler fails when the workspace exists but is neither a project nor a git repository', async () => {
+    await withTempDir(async (dir) => {
+        const plainDir = join(dir, 'plain');
+        await mkdir(plainDir);
+        const clientCalls = [];
+        let runnerCalled = false;
+        const client = {
+            fetchTriggerRuntime: async () => ({ ...runtime, authPath: plainDir }),
+            isTriggerCancelRequested: async () => false,
+            updateTriggerHistory: async () => undefined,
+            updateTriggerStatus: async (...args) => {
+                clientCalls.push({ method: 'updateTriggerStatus', args });
+            },
+        };
+        const handler = createTriggerHandler({
+            config: {
+                daemonToken: 'daemon-token',
+                apiUrl: 'https://api.example',
+                pollingIntervalMs: 5000,
+                maxPollingIntervalMs: 120_000,
+                timeoutMs: 1500,
+                idleTimeoutMs: 500,
+                runnerCmd: 'opencode',
+                preventSleepWhileBusy: false,
+            },
+            client: client,
+        }, {
+            createRunnerFactory: () => () => ({
+                run: async () => {
+                    runnerCalled = true;
+                    return { exitCode: 0 };
+                },
+            }),
+            createLogReporter: () => ({
+                start: () => undefined,
+                append: () => undefined,
+                stop: async () => undefined,
+            }),
+            readHistoryFile: async () => '',
+        });
+        await handler({ ...trigger, parentTriggerId: null });
+        assert.equal(runnerCalled, false);
+        assert.equal(existsSync(join(plainDir, '.agentteams')), false);
+        assert.equal(clientCalls.at(-1)?.args[1], 'FAILED');
+        assert.match(String(clientCalls.at(-1)?.args[2]), /is neither a git repository nor an AgentTeams project/);
+    });
+});
+test('createTriggerHandler runs normally when the workspace carries the project marker', async () => {
+    await withTempDir(async (dir) => {
+        const runnerInputs = [];
+        const clientCalls = [];
+        const client = {
+            fetchTriggerRuntime: async () => ({ ...runtime, authPath: dir }),
+            isTriggerCancelRequested: async () => false,
+            updateTriggerHistory: async () => undefined,
+            updateTriggerStatus: async (...args) => {
+                clientCalls.push({ method: 'updateTriggerStatus', args });
+            },
+        };
+        const handler = createTriggerHandler({
+            config: {
+                daemonToken: 'daemon-token',
+                apiUrl: 'https://api.example',
+                pollingIntervalMs: 5000,
+                maxPollingIntervalMs: 120_000,
+                timeoutMs: 1500,
+                idleTimeoutMs: 500,
+                runnerCmd: 'opencode',
+                preventSleepWhileBusy: false,
+            },
+            client: client,
+        }, {
+            createRunnerFactory: () => () => ({
+                run: async (input) => {
+                    runnerInputs.push({ authPath: input.authPath });
+                    return { exitCode: 0 };
+                },
+            }),
+            createLogReporter: () => ({
+                start: () => undefined,
+                append: () => undefined,
+                stop: async () => undefined,
+            }),
+            readHistoryFile: async () => '### Summary\n- done\n',
+            resolveRunnerHistoryPaths: () => ({
+                currentHistoryPath: join(dir, '.agentteams/runner/history/trigger-1.md'),
+                parentHistoryPath: null,
+            }),
+        });
+        await handler({ ...trigger, parentTriggerId: null });
+        assert.deepEqual(runnerInputs, [{ authPath: dir }]);
+        assert.equal(clientCalls.at(-1)?.args[1], 'DONE');
+    });
+});
+test('createTriggerHandler fails when the workspace marker belongs to another project', async () => {
+    await withTempDir(async (dir) => {
+        // 같은 사용자명·같은 디렉터리 배치를 쓰는 머신에서는 다른 머신의 authPath가 "존재하는 어떤
+        // 프로젝트"에 그대로 맞아떨어진다. 마커의 projectId까지 대조해야 조용한 오실행이 사라진다.
+        const otherProjectDir = join(dir, 'other-project');
+        await mkdir(join(otherProjectDir, '.agentteams'), { recursive: true });
+        await writeFile(join(otherProjectDir, '.agentteams', 'config.json'), `${JSON.stringify({ projectId: 'project-other' })}\n`, 'utf8');
+        const clientCalls = [];
+        let runnerCalled = false;
+        const client = {
+            fetchTriggerRuntime: async () => ({ ...runtime, authPath: otherProjectDir }),
+            isTriggerCancelRequested: async () => false,
+            updateTriggerHistory: async () => undefined,
+            updateTriggerStatus: async (...args) => {
+                clientCalls.push({ method: 'updateTriggerStatus', args });
+            },
+        };
+        const handler = createTriggerHandler({
+            config: {
+                daemonToken: 'daemon-token',
+                apiUrl: 'https://api.example',
+                pollingIntervalMs: 5000,
+                maxPollingIntervalMs: 120_000,
+                timeoutMs: 1500,
+                idleTimeoutMs: 500,
+                runnerCmd: 'opencode',
+                preventSleepWhileBusy: false,
+            },
+            client: client,
+        }, {
+            isGitRepo: () => true,
+            createRunnerFactory: () => () => ({
+                run: async () => {
+                    runnerCalled = true;
+                    return { exitCode: 0 };
+                },
+            }),
+            createLogReporter: () => ({
+                start: () => undefined,
+                append: () => undefined,
+                stop: async () => undefined,
+            }),
+            readHistoryFile: async () => '',
+        });
+        await handler({ ...trigger, parentTriggerId: null });
+        assert.equal(runnerCalled, false);
+        assert.equal(clientCalls.at(-1)?.args[1], 'FAILED');
+        assert.match(String(clientCalls.at(-1)?.args[2]), /belongs to a different AgentTeams project/);
+    });
+});
+test('createTriggerHandler skips the pre-flight for worktree runs that already validate their path', async () => {
+    await withTempDir(async (dir) => {
+        // RunnerBox 경로는 authPath가 아니라 생성된 워크트리에서 실행되므로, 마커가 없는 git 저장소
+        // 루트여도 기존 동작(worktree 생성 후 실행)이 유지되어야 한다.
+        const repoDir = join(dir, 'repo');
+        await mkdir(repoDir);
+        const worktreePath = join(dir, 'worktrees', 'wt-1');
+        const runnerInputs = [];
+        const clientCalls = [];
+        const client = {
+            fetchTriggerRuntime: async () => ({ ...runtime, authPath: repoDir, useWorktree: true, worktreeId: 'wt-1' }),
+            isTriggerCancelRequested: async () => false,
+            updateTriggerHistory: async () => undefined,
+            reportWorktreeStatus: async () => undefined,
+            updateTriggerStatus: async (...args) => {
+                clientCalls.push({ method: 'updateTriggerStatus', args });
+            },
+        };
+        const handler = createTriggerHandler({
+            config: {
+                daemonToken: 'daemon-token',
+                apiUrl: 'https://api.example',
+                pollingIntervalMs: 5000,
+                maxPollingIntervalMs: 120_000,
+                timeoutMs: 1500,
+                idleTimeoutMs: 500,
+                runnerCmd: 'opencode',
+                preventSleepWhileBusy: false,
+            },
+            client: client,
+        }, {
+            isGitRepo: () => true,
+            createWorktree: () => worktreePath,
+            createRunnerFactory: () => () => ({
+                run: async (input) => {
+                    runnerInputs.push({ authPath: input.authPath });
+                    return { exitCode: 0 };
+                },
+            }),
+            createLogReporter: () => ({
+                start: () => undefined,
+                append: () => undefined,
+                stop: async () => undefined,
+            }),
+            readHistoryFile: async () => '### Summary\n- done\n',
+            resolveRunnerHistoryPaths: () => ({
+                currentHistoryPath: join(worktreePath, '.agentteams/runner/history/trigger-1.md'),
+                parentHistoryPath: null,
+            }),
+        });
+        await handler({ ...trigger, useWorktree: true, worktreeId: 'wt-1', parentTriggerId: null });
+        assert.deepEqual(runnerInputs, [{ authPath: worktreePath }]);
+        assert.equal(clientCalls.at(-1)?.args[1], 'DONE');
+    });
+});
 //# sourceMappingURL=trigger-handler.test.js.map