@stilero/bankan 1.0.13 → 1.0.17

package/server/src/config.test.js

@@ -0,0 +1,170 @@
+import { afterEach, describe, expect, test } from 'vitest';
+
+import { createRuntimeHarness } from '../test-utils.js';
+
+let harness = null;
+
+afterEach(() => {
+  harness?.cleanup();
+  harness = null;
+});
+
+describe('config settings lifecycle', () => {
+  test('loadSettings falls back to defaults and normalizes repo selection', async () => {
+    harness = createRuntimeHarness();
+    const configModule = await harness.importModule('./src/config.js');
+
+    const defaults = configModule.getDefaults();
+    expect(defaults.agents.planners.max).toBe(4);
+    expect(configModule.loadSettings().defaultRepoPath).toBe(defaults.defaultRepoPath);
+    expect(configModule.getWorkspacesDir()).toContain(harness.runtimeDir);
+  });
+
+  test('saveSettings persists normalized settings shape', async () => {
+    harness = createRuntimeHarness();
+    const configModule = await harness.importModule('./src/config.js');
+
+    configModule.saveSettings({
+      repos: ['/repo-a', '/repo-b'],
+      defaultRepoPath: '/missing',
+      reposDir: '/legacy-root',
+      workspaceRoot: '',
+      agents: {
+        planners: { max: 0, cli: 'claude', count: 1 },
+        implementors: { max: 2, cli: 'codex', count: 8 },
+        reviewers: { max: 1, cli: 'claude', count: 3 },
+      },
+      prompts: {
+        implementation: 'Custom implementation prompt',
+      },
+    });
+
+    const loaded = configModule.loadSettings();
+    expect(loaded.defaultRepoPath).toBe('/repo-a');
+    expect(loaded.workspaceRoot).toBe('/legacy-root');
+    expect(loaded.agents.planners.count).toBeUndefined();
+    expect(loaded.prompts.planning).toContain('Plan Mode Instructions');
+    expect(loaded.prompts.implementation).toBe('Custom implementation prompt');
+  });
+
+  test('validateSettings reports invalid values across roles and prompts', async () => {
+    harness = createRuntimeHarness();
+    const { validateSettings } = await harness.importModule('./src/config.js');
+
+    const errors = validateSettings({
+      repos: ['/repo-a'],
+      defaultRepoPath: '/repo-b',
+      workspaceRoot: '',
+      agents: {
+        planners: { max: -1, cli: 'bad-cli' },
+        implementors: { max: 0, cli: 'codex' },
+        reviewers: { max: 11, cli: 'claude' },
+      },
+      prompts: {
+        planning: 'ok',
+        implementation: 12,
+      },
+    });
+
+    expect(errors).toContain('workspaceRoot is required');
+    expect(errors).toContain('defaultRepoPath must match one of the configured repos');
+    expect(errors).toContain('planners.max must be between 0 and 10');
+    expect(errors).toContain('planners.cli must be one of: claude, codex');
+    expect(errors).toContain('implementors.max must be between 1 and 10');
+    expect(errors).toContain('reviewers.max must be between 0 and 10');
+    expect(errors).toContain('prompts.implementation must be a string');
+    expect(errors).toContain('prompts.review must be a string');
+  });
+
+  test('reads env defaults for repos, port, and legacy implementor cli', async () => {
+    harness = createRuntimeHarness();
+    const { writeFileSync } = await import('node:fs');
+    writeFileSync(`${harness.runtimeDir}/.env.local`, [
+      'PORT=4010',
+      'REPOS=/repo-a,/repo-b',
+      'IMPLEMENTOR_1_CLI=codex',
+      '# comment',
+      'MALFORMED',
+    ].join('\n'));
+
+    const configModule = await harness.importModule('./src/config.js');
+
+    expect(configModule.default.PORT).toBe(4010);
+    expect(configModule.default.REPOS).toEqual(['/repo-a', '/repo-b']);
+    expect(configModule.getDefaults().agents.implementors.cli).toBe('codex');
+  });
+
+  test('defaults include model field for all agent roles', async () => {
+    harness = createRuntimeHarness();
+    const { getDefaults } = await harness.importModule('./src/config.js');
+    const defaults = getDefaults();
+    for (const role of ['planners', 'implementors', 'reviewers']) {
+      expect(defaults.agents[role].model).toBe('');
+    }
+  });
+
+  test('normalizeSettingsShape backfills missing model field', async () => {
+    harness = createRuntimeHarness();
+    const configModule = await harness.importModule('./src/config.js');
+
+    configModule.saveSettings({
+      repos: ['/repo-a'],
+      defaultRepoPath: '/repo-a',
+      workspaceRoot: '/tmp/ws',
+      agents: {
+        planners: { max: 2, cli: 'claude' },
+        implementors: { max: 4, cli: 'claude' },
+        reviewers: { max: 2, cli: 'claude' },
+      },
+      prompts: {
+        planning: 'p', implementation: 'i', review: 'r',
+      },
+    });
+
+    const loaded = configModule.loadSettings();
+    expect(loaded.agents.planners.model).toBe('');
+    expect(loaded.agents.implementors.model).toBe('');
+    expect(loaded.agents.reviewers.model).toBe('');
+  });
+
+  test('validateSettings accepts valid model strings and rejects non-strings', async () => {
+    harness = createRuntimeHarness();
+    const { validateSettings } = await harness.importModule('./src/config.js');
+
+    const base = {
+      repos: ['/repo'],
+      defaultRepoPath: '/repo',
+      workspaceRoot: '/tmp/ws',
+      agents: {
+        planners: { max: 1, cli: 'claude', model: 'haiku' },
+        implementors: { max: 1, cli: 'claude', model: 'opus' },
+        reviewers: { max: 1, cli: 'claude', model: '' },
+      },
+      prompts: { planning: 'p', implementation: 'i', review: 'r' },
+    };
+    expect(validateSettings(base)).toEqual([]);
+
+    const bad = JSON.parse(JSON.stringify(base));
+    bad.agents.planners.model = 42;
+    const errors = validateSettings(bad);
+    expect(errors).toContain('planners.model must be a string');
+  });
+
+  test('returns early when agents are missing and validates repo types', async () => {
+    harness = createRuntimeHarness();
+    const { validateSettings } = await harness.importModule('./src/config.js');
+
+    expect(validateSettings({})).toEqual(['Missing agents configuration']);
+    expect(validateSettings({
+      agents: {
+        planners: { max: 0, cli: 'claude' },
+        implementors: { max: 1, cli: 'codex' },
+        reviewers: { max: 0, cli: 'claude' },
+      },
+      workspaceRoot: '/tmp/workspaces',
+      repos: 'not-an-array',
+      defaultRepoPath: 123,
+      prompts: {},
+    })).toContain('repos must be an array');
+  });
+});

package/server/src/index.js

@@ -94,7 +94,7 @@ app.get('/api/browse-dir', (req, res) => {
       parent: parent !== absPath ? parent : null,
       dirs,
     });
-  } catch (err) {
+  } catch {
     res.status(403).json({ error: 'Permission denied' });
   }
 });
@@ -186,7 +186,7 @@ function sendToClient(ws, type, payload) {
 }
 
 function shellQuote(value) {
-  return `'${String(value).replace(/'/g, `'\\''`)}'`;
+  return `'${String(value).replace(/'/g, '\'\\\'\'')}'`;
 }
 
 function ensureBridgeFiles() {
@@ -607,6 +607,15 @@ wss.on('connection', (ws) => {
         }
         break;
       }
+      case 'RESIZE_TERMINAL': {
+        const { agentId, cols, rows } = msg.payload || {};
+        const agent = agentManager.get(agentId);
+        if (agent) {
+          agent.resize(cols, rows);
+          bus.emit('agent:updated', agent.getStatus());
+        }
+        break;
+      }
       case 'OPEN_TASK_WORKSPACE': {
         const { taskId } = msg.payload || {};
         const result = openTaskWorkspace(taskId);

package/server/src/linting.test.js

@@ -0,0 +1,37 @@
+import { execFileSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { describe, expect, test } from 'vitest';
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..', '..');
+
+describe('linting integration', () => {
+  test('exposes a working root lint command', () => {
+    expect(() => execFileSync('npm', ['run', 'lint'], {
+      cwd: repoRoot,
+      stdio: 'pipe',
+    })).not.toThrow();
+  });
+
+  test('checks in Claude project hooks for lint enforcement', () => {
+    const settingsPath = resolve(repoRoot, '.claude', 'settings.json');
+
+    expect(existsSync(settingsPath)).toBe(true);
+
+    const settings = JSON.parse(readFileSync(settingsPath, 'utf-8'));
+    const postToolUseHooks = settings.hooks?.PostToolUse || [];
+    const taskCompletedHooks = settings.hooks?.TaskCompleted || [];
+
+    expect(postToolUseHooks).toHaveLength(1);
+    expect(postToolUseHooks[0].matcher).toBe('Edit|Write|MultiEdit');
+    expect(postToolUseHooks[0].hooks[0].type).toBe('command');
+    expect(postToolUseHooks[0].hooks[0].command).toContain('.claude/hooks/run-lint-on-edit.sh');
+    expect(postToolUseHooks[0].hooks[0].timeout).toBe(60);
+
+    expect(taskCompletedHooks).toHaveLength(1);
+    expect(taskCompletedHooks[0].hooks[0].type).toBe('command');
+    expect(taskCompletedHooks[0].hooks[0].command).toContain('.claude/hooks/run-lint-on-task-complete.sh');
+    expect(taskCompletedHooks[0].hooks[0].timeout).toBe(300);
+  });
+});