@assistkick/create 1.10.0 → 1.11.0

package/templates/assistkick-product-system/packages/backend/src/routes/git_branches.test.ts

@@ -0,0 +1,306 @@
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createGitRoutes } from './git.ts';
+import express from 'express';
+import type { Server } from 'node:http';
+
+const createMockDeps = (overrides: Record<string, any> = {}) => ({
+  projectService: {
+    getById: mock.fn(async () => ({ id: 'proj_1', repoUrl: 'https://github.com/org/repo.git' })),
+    connectRepo: mock.fn(async () => ({ id: 'proj_1' })),
+    ...overrides.projectService,
+  },
+  githubAppService: {
+    isConfigured: mock.fn(() => false),
+    getInstallationToken: mock.fn(async () => 'token123'),
+    ...overrides.githubAppService,
+  },
+  workspaceService: {
+    hasWorkspace: mock.fn(() => true),
+    getWorkspacePath: mock.fn(() => '/tmp/ws/proj_1'),
+    listBranches: mock.fn(async () => ({
+      current: 'main',
+      local: ['main', 'develop'],
+      remote: ['origin/main', 'origin/develop', 'origin/feature-x'],
+    })),
+    hasUncommittedChanges: mock.fn(async () => false),
+    commitAll: mock.fn(async () => {}),
+    checkoutBranch: mock.fn(async () => {}),
+    createBranch: mock.fn(async () => {}),
+    listRemotes: mock.fn(async () => [{ name: 'origin', url: 'https://github.com/org/repo.git' }]),
+    addRemote: mock.fn(async () => {}),
+    fetchRemote: mock.fn(async () => {}),
+    fetchRemoteSsh: mock.fn(async () => {}),
+    pullBranch: mock.fn(async () => {}),
+    pullBranchSsh: mock.fn(async () => {}),
+    pushBranch: mock.fn(async () => {}),
+    pushBranchSsh: mock.fn(async () => {}),
+    getAheadBehind: mock.fn(async () => ({ ahead: 2, behind: 1 })),
+    hasOnlyInitialCommit: mock.fn(async () => false),
+    resetToRemoteBranch: mock.fn(async () => {}),
+    getDefaultBranch: mock.fn(async () => 'main'),
+    getCurrentBranch: mock.fn(async () => 'main'),
+    ...overrides.workspaceService,
+  },
+  sshKeyService: {
+    isConfigured: mock.fn(() => false),
+    ...overrides.sshKeyService,
+  },
+  log: mock.fn(),
+});
+
+const createTestApp = (deps: any) => {
+  const app = express();
+  app.use(express.json());
+  const gitRoutes = createGitRoutes(deps);
+  app.use('/api/projects/:id/git', gitRoutes);
+  return app;
+};
+
+const request = (server: Server) => {
+  const addr = server.address() as { port: number };
+  const base = `http://127.0.0.1:${addr.port}`;
+  return {
+    get: async (path: string) => {
+      const res = await fetch(`${base}${path}`);
+      return { status: res.status, body: await res.json() };
+    },
+    post: async (path: string, body?: any) => {
+      const res = await fetch(`${base}${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body || {}),
+      });
+      return { status: res.status, body: await res.json() };
+    },
+  };
+};
+
+describe('Git Branch Routes', () => {
+  let server: Server;
+  let http: ReturnType<typeof request>;
+  let deps: ReturnType<typeof createMockDeps>;
+
+  beforeEach(async () => {
+    deps = createMockDeps();
+    const app = createTestApp(deps);
+    server = await new Promise<Server>((resolve) => {
+      const s = app.listen(0, '127.0.0.1', () => resolve(s));
+    });
+    http = request(server);
+  });
+
+  afterEach(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  });
+
+  describe('GET /branches', () => {
+    it('returns local and remote branches with current branch', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/git/branches');
+      assert.equal(status, 200);
+      assert.equal(body.current, 'main');
+      assert.deepEqual(body.local, ['main', 'develop']);
+      assert.deepEqual(body.remote, ['origin/main', 'origin/develop', 'origin/feature-x']);
+    });
+
+    it('returns 404 when no workspace exists', async () => {
+      deps.workspaceService.hasWorkspace = mock.fn(() => false);
+      const app = createTestApp(deps);
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+      server = await new Promise<Server>((resolve) => {
+        const s = app.listen(0, '127.0.0.1', () => resolve(s));
+      });
+      http = request(server);
+
+      const { status, body } = await http.get('/api/projects/proj_1/git/branches');
+      assert.equal(status, 404);
+      assert.ok(body.error.includes('No git workspace'));
+    });
+  });
+
+  describe('POST /checkout', () => {
+    it('switches to the specified branch', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/checkout', {
+        branch: 'develop',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.equal(deps.workspaceService.checkoutBranch.mock.calls.length, 1);
+    });
+
+    it('returns 400 when branch is missing', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/checkout', {});
+      assert.equal(status, 400);
+      assert.ok(body.error.includes('branch is required'));
+    });
+
+    it('returns 409 when dirty with no commit message', async () => {
+      deps.workspaceService.hasUncommittedChanges = mock.fn(async () => true);
+      const app = createTestApp(deps);
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+      server = await new Promise<Server>((resolve) => {
+        const s = app.listen(0, '127.0.0.1', () => resolve(s));
+      });
+      http = request(server);
+
+      const { status, body } = await http.post('/api/projects/proj_1/git/checkout', {
+        branch: 'develop',
+      });
+      assert.equal(status, 409);
+      assert.equal(body.dirty, true);
+    });
+
+    it('commits and switches when dirty with commit message', async () => {
+      deps.workspaceService.hasUncommittedChanges = mock.fn(async () => true);
+      const app = createTestApp(deps);
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+      server = await new Promise<Server>((resolve) => {
+        const s = app.listen(0, '127.0.0.1', () => resolve(s));
+      });
+      http = request(server);
+
+      const { status, body } = await http.post('/api/projects/proj_1/git/checkout', {
+        branch: 'develop',
+        commitMessage: 'Save work',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.equal(deps.workspaceService.commitAll.mock.calls.length, 1);
+      assert.equal(deps.workspaceService.checkoutBranch.mock.calls.length, 1);
+    });
+  });
+
+  describe('POST /branches (create)', () => {
+    it('creates and checks out a new branch', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/branches', {
+        name: 'feature-new',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.equal(deps.workspaceService.createBranch.mock.calls.length, 1);
+    });
+
+    it('returns 400 when name is missing', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/branches', {});
+      assert.equal(status, 400);
+      assert.ok(body.error.includes('name is required'));
+    });
+
+    it('returns 400 for invalid branch names', async () => {
+      const invalidNames = ['has space', 'has..dots', '-starts-with-dash', 'has~tilde', 'has:colon'];
+      for (const name of invalidNames) {
+        const { status, body } = await http.post('/api/projects/proj_1/git/branches', { name });
+        assert.equal(status, 400, `Expected 400 for "${name}"`);
+        assert.ok(body.error.includes('Invalid branch name'), `Expected invalid branch name error for "${name}"`);
+      }
+    });
+
+    it('returns 404 when no workspace exists', async () => {
+      deps.workspaceService.hasWorkspace = mock.fn(() => false);
+      const app = createTestApp(deps);
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+      server = await new Promise<Server>((resolve) => {
+        const s = app.listen(0, '127.0.0.1', () => resolve(s));
+      });
+      http = request(server);
+
+      const { status, body } = await http.post('/api/projects/proj_1/git/branches', {
+        name: 'feature-new',
+      });
+      assert.equal(status, 404);
+      assert.ok(body.error.includes('No git workspace'));
+    });
+  });
+
+  describe('GET /remotes', () => {
+    it('returns configured remotes', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/git/remotes');
+      assert.equal(status, 200);
+      assert.equal(body.remotes.length, 1);
+      assert.equal(body.remotes[0].name, 'origin');
+    });
+
+    it('returns 404 when no workspace', async () => {
+      deps.workspaceService.hasWorkspace = mock.fn(() => false);
+      const app = createTestApp(deps);
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+      server = await new Promise<Server>((resolve) => {
+        const s = app.listen(0, '127.0.0.1', () => resolve(s));
+      });
+      http = request(server);
+
+      const { status } = await http.get('/api/projects/proj_1/git/remotes');
+      assert.equal(status, 404);
+    });
+  });
+
+  describe('POST /remotes', () => {
+    it('adds a new remote', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/remotes', {
+        url: 'https://github.com/org/other.git',
+      });
+      assert.equal(status, 200);
+      assert.equal(body.success, true);
+      assert.equal(deps.workspaceService.addRemote.mock.calls.length, 1);
+    });
+
+    it('returns 400 when url is missing', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/remotes', {});
+      assert.equal(status, 400);
+      assert.ok(body.error.includes('url is required'));
+    });
+  });
+
+  describe('POST /fetch', () => {
+    it('fetches from remote and returns ahead/behind', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/fetch', {});
+      assert.equal(status, 200);
+      assert.equal(body.ahead, 2);
+      assert.equal(body.behind, 1);
+      assert.equal(deps.workspaceService.fetchRemote.mock.calls.length, 1);
+    });
+  });
+
+  describe('POST /pull', () => {
+    it('pulls and returns ahead/behind', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/pull', {});
+      assert.equal(status, 200);
+      assert.equal(body.ahead, 2);
+      assert.equal(body.behind, 1);
+      assert.equal(deps.workspaceService.pullBranch.mock.calls.length, 1);
+    });
+
+    it('does a force reset when force=true', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/pull', { force: true });
+      assert.equal(status, 200);
+      assert.equal(deps.workspaceService.resetToRemoteBranch.mock.calls.length, 1);
+    });
+  });
+
+  describe('POST /push', () => {
+    it('pushes and returns ahead/behind', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/push', {});
+      assert.equal(status, 200);
+      assert.equal(body.ahead, 2);
+      assert.equal(body.behind, 1);
+      assert.equal(deps.workspaceService.pushBranch.mock.calls.length, 1);
+    });
+  });
+
+  describe('GET /ahead-behind', () => {
+    it('returns ahead and behind counts', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/git/ahead-behind');
+      assert.equal(status, 200);
+      assert.equal(body.ahead, 2);
+      assert.equal(body.behind, 1);
+    });
+  });
+
+  describe('GET /initial-commit', () => {
+    it('returns onlyInitialCommit flag', async () => {
+      const { status, body } = await http.get('/api/projects/proj_1/git/initial-commit');
+      assert.equal(status, 200);
+      assert.equal(body.onlyInitialCommit, false);
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/routes/git_connect.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert/strict';
+import { createGitRoutes } from './git.ts';
+import express from 'express';
+import type { Server } from 'node:http';
+
+const createMockDeps = (overrides: Record<string, any> = {}) => ({
+  projectService: {
+    getById: mock.fn(async () => ({ id: 'proj_1', repoUrl: null, gitAuthMethod: null })),
+    connectRepo: mock.fn(async (_id: string, opts: any) => ({
+      id: 'proj_1',
+      repoUrl: opts.repoUrl,
+      githubInstallationId: opts.githubInstallationId || null,
+      githubRepoFullName: opts.githubRepoFullName || null,
+      baseBranch: opts.baseBranch || null,
+      gitAuthMethod: null,
+    })),
+    setGitHubAppAuth: mock.fn(async () => ({
+      id: 'proj_1',
+      gitAuthMethod: 'github_app',
+    })),
+    ...overrides.projectService,
+  },
+  githubAppService: {
+    isConfigured: mock.fn(() => true),
+    getInstallationToken: mock.fn(async () => 'token123'),
+    buildAuthenticatedCloneUrl: mock.fn(async () => 'https://x-access-token:token123@github.com/org/repo.git'),
+    ...overrides.githubAppService,
+  },
+  workspaceService: {
+    hasWorkspace: mock.fn(() => true),
+    getWorkspacePath: mock.fn(() => '/tmp/ws/proj_1'),
+    cloneRepo: mock.fn(async () => {}),
+    getDefaultBranch: mock.fn(async () => 'main'),
+    hasOnlyInitialCommit: mock.fn(async () => false),
+    resetToRemoteBranch: mock.fn(async () => {}),
+    listBranches: mock.fn(async () => ({ current: 'main', local: ['main'], remote: ['origin/main'] })),
+    hasUncommittedChanges: mock.fn(async () => false),
+    commitAll: mock.fn(async () => {}),
+    checkoutBranch: mock.fn(async () => {}),
+    createBranch: mock.fn(async () => {}),
+    listRemotes: mock.fn(async () => []),
+    addRemote: mock.fn(async () => {}),
+    fetchRemote: mock.fn(async () => {}),
+    fetchRemoteSsh: mock.fn(async () => {}),
+    pullBranch: mock.fn(async () => {}),
+    pullBranchSsh: mock.fn(async () => {}),
+    pushBranch: mock.fn(async () => {}),
+    pushBranchSsh: mock.fn(async () => {}),
+    getAheadBehind: mock.fn(async () => ({ ahead: 0, behind: 0 })),
+    getCurrentBranch: mock.fn(async () => 'main'),
+    ...overrides.workspaceService,
+  },
+  sshKeyService: {
+    isConfigured: mock.fn(() => false),
+    ...overrides.sshKeyService,
+  },
+  log: mock.fn(),
+});
+
+const createTestApp = (deps: any) => {
+  const app = express();
+  app.use(express.json());
+  const gitRoutes = createGitRoutes(deps);
+  app.use('/api/projects/:id/git', gitRoutes);
+  return app;
+};
+
+const request = (server: Server) => {
+  const addr = server.address() as { port: number };
+  const base = `http://127.0.0.1:${addr.port}`;
+  return {
+    post: async (path: string, body?: any) => {
+      const res = await fetch(`${base}${path}`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(body || {}),
+      });
+      return { status: res.status, body: await res.json() };
+    },
+  };
+};
+
+describe('Git Connect Routes', () => {
+  let server: Server;
+  let http: ReturnType<typeof request>;
+  let deps: ReturnType<typeof createMockDeps>;
+
+  beforeEach(async () => {
+    deps = createMockDeps();
+    const app = createTestApp(deps);
+    server = await new Promise<Server>((resolve) => {
+      const s = app.listen(0, '127.0.0.1', () => resolve(s));
+    });
+    http = request(server);
+  });
+
+  afterEach(async () => {
+    await new Promise<void>((resolve) => server.close(() => resolve()));
+  });
+
+  describe('POST /connect', () => {
+    it('calls setGitHubAppAuth when githubInstallationId is provided', async () => {
+      const { status } = await http.post('/api/projects/proj_1/git/connect', {
+        githubRepoFullName: 'org/repo',
+        githubInstallationId: 'inst_123',
+      });
+
+      assert.equal(status, 200);
+      assert.equal(deps.projectService.setGitHubAppAuth.mock.calls.length, 1);
+      assert.equal(deps.projectService.setGitHubAppAuth.mock.calls[0].arguments[0], 'proj_1');
+    });
+
+    it('does not call setGitHubAppAuth when no githubInstallationId', async () => {
+      const { status } = await http.post('/api/projects/proj_1/git/connect', {
+        repoUrl: 'https://github.com/org/repo.git',
+      });
+
+      assert.equal(status, 200);
+      assert.equal(deps.projectService.setGitHubAppAuth.mock.calls.length, 0);
+    });
+
+    it('returns the project with github_app auth method set', async () => {
+      const { status, body } = await http.post('/api/projects/proj_1/git/connect', {
+        githubRepoFullName: 'org/repo',
+        githubInstallationId: 'inst_123',
+      });
+
+      assert.equal(status, 200);
+      assert.equal(body.project.gitAuthMethod, 'github_app');
+    });
+  });
+});

package/templates/assistkick-product-system/packages/backend/src/routes/pipeline.ts

@@ -49,7 +49,7 @@ export const createWorkflowExecutionRoutes = ({
       const result = await workflowEngine.start(featureId, resolvedWorkflowId, projectId);
       res.json({ started: true, feature_id: featureId, executionId: result.executionId });
     } catch (err: any) {
-      log('WORKFLOW', `START ERROR: ${err.message}`);
+      log('WORKFLOW', `START ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -61,7 +61,7 @@ export const createWorkflowExecutionRoutes = ({
       const status = await workflowEngine.getStatus(featureId);
       res.json(status);
     } catch (err: any) {
-      log('WORKFLOW', `STATUS ERROR: ${err.message}`);
+      log('WORKFLOW', `STATUS ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -82,7 +82,7 @@ export const createWorkflowExecutionRoutes = ({
       await workflowEngine.resume(executionId);
       res.json({ resumed: true, feature_id: featureId, executionId });
     } catch (err: any) {
-      log('WORKFLOW', `RESUME ERROR: ${err.message}`);
+      log('WORKFLOW', `RESUME ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -102,7 +102,7 @@ export const createWorkflowExecutionRoutes = ({
       await workflowEngine.forceNextNode(featureId, nodeId);
       res.json({ success: true, feature_id: featureId, skippedNodeId: nodeId });
     } catch (err: any) {
-      log('WORKFLOW', `FORCE-NEXT ERROR: ${err.message}`);
+      log('WORKFLOW', `FORCE-NEXT ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -122,11 +122,68 @@ export const createWorkflowExecutionRoutes = ({
       await workflowEngine.restartNode(featureId, nodeId);
       res.json({ success: true, feature_id: featureId, restartedNodeId: nodeId });
     } catch (err: any) {
-      log('WORKFLOW', `RESTART-NODE ERROR: ${err.message}`);
+      log('WORKFLOW', `RESTART-NODE ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
 
+  // POST /api/kanban/:id/workflow/stop-node — stop the currently executing node
+  router.post('/:id/workflow/stop-node', async (req, res) => {
+    const featureId = req.params.id;
+    const { nodeId } = req.body || {};
+    log('WORKFLOW', `POST /api/kanban/${featureId}/workflow/stop-node nodeId=${nodeId}`);
+
+    if (!nodeId) {
+      res.status(400).json({ error: 'nodeId is required' });
+      return;
+    }
+
+    try {
+      await workflowEngine.stopNode(featureId, nodeId);
+      // If orchestrator Play All is active, abort it
+      if (orchestrator.getStatus().active) {
+        orchestrator.stopPlayAll();
+        log('WORKFLOW', 'Play All aborted due to user stop');
+      }
+      res.json({ success: true, feature_id: featureId, stoppedNodeId: nodeId });
+    } catch (err: any) {
+      log('WORKFLOW', `STOP-NODE ERROR: ${err.message}`);
+      if (err.message.includes('No running execution')) {
+        res.status(404).json({ error: err.message });
+      } else if (err.message.includes('not the current')) {
+        res.status(400).json({ error: err.message });
+      } else {
+        res.status(500).json({ error: err.message });
+      }
+    }
+  });
+
+  // POST /api/kanban/:id/workflow/continue-node — resume a stuck/failed agent node
+  router.post('/:id/workflow/continue-node', async (req, res) => {
+    const featureId = req.params.id;
+    const { nodeId } = req.body || {};
+    log('WORKFLOW', `POST /api/kanban/${featureId}/workflow/continue-node nodeId=${nodeId}`);
+
+    if (!nodeId) {
+      res.status(400).json({ error: 'nodeId is required' });
+      return;
+    }
+
+    try {
+      await workflowEngine.continueNode(featureId, nodeId);
+      res.json({ success: true, feature_id: featureId, continuedNodeId: nodeId });
+    } catch (err: any) {
+      log('WORKFLOW', `CONTINUE-NODE ERROR: ${err.message}`);
+      if (err.message.includes('No execution found')) {
+        res.status(404).json({ error: err.message });
+      } else if (err.message.includes('no Claude session ID')) {
+        res.status(400).json({ error: err.message });
+      } else {
+        res.status(500).json({ error: err.message });
+      }
+    }
+  });
+
   // GET /api/kanban/:id/workflow-monitor — get full execution monitor data for a feature
   router.get('/:id/workflow-monitor', async (req, res) => {
     const featureId = req.params.id;
@@ -138,7 +195,7 @@ export const createWorkflowExecutionRoutes = ({
       }
       res.json({ monitor: data });
     } catch (err: any) {
-      log('WORKFLOW', `MONITOR ERROR: ${err.message}`);
+      log('WORKFLOW', `MONITOR ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -156,7 +213,7 @@ export const createWorkflowExecutionRoutes = ({
       const metrics = await workflowEngine.getExecutionMetrics(executionId);
       res.json({ metrics });
     } catch (err: any) {
-      log('WORKFLOW', `METRICS ERROR: ${err.message}`);
+      log('WORKFLOW', `METRICS ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -177,7 +234,7 @@ export const createWorkflowExecutionRoutes = ({
         result.error ? { error: result.error } : { started: result.started },
       );
     } catch (err: any) {
-      log('ORCHESTRATOR', `UNEXPECTED ERROR: ${err.message}`);
+      log('ORCHESTRATOR', `UNEXPECTED ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });
@@ -190,7 +247,7 @@ export const createWorkflowExecutionRoutes = ({
         result.error ? { error: result.error } : { stopped: result.stopped },
       );
     } catch (err: any) {
-      log('ORCHESTRATOR', `UNEXPECTED ERROR: ${err.message}`);
+      log('ORCHESTRATOR', `UNEXPECTED ERROR:`, err.stack || err.message);
       res.status(500).json({ error: err.message });
     }
   });