@vantran-se/openchamber-web 2.1.1 → 2.2.0

package/server/lib/gitlab/routes.js

@@ -84,6 +84,16 @@ function sendAuthStorageError(res, error) {
   return null;
 }
 
+/** A list's state and whose items, from the query; unknown values read as open and anyone. */
+function readListFilter(query) {
+  const state = requestText(query?.state);
+  const people = requestText(query?.people);
+  return {
+    state: ['open', 'closed', 'merged', 'all'].includes(state) ? state : 'open',
+    people: ['any', 'assigned', 'created', 'reviewRequested'].includes(people) ? people : 'any',
+  };
+}
+
 function requestText(value) {
   return isString(value) ? value.trim() : '';
 }
@@ -420,20 +430,21 @@ export function registerGitLabRoutes(app, options = {}) {
         record: mutationRecord(context, kind, actor, credential, existing.target, normalized.digest),
         providerAccountId: resource.providerUserId,
         perform: () => { throw mutationConflict(); },
-        reconcile: async () => reconcile(service, await resolveReplay()),
+        reconcile: async () => reconcile(service, await resolveReplay(), normalized),
         classifyError: classifyMutationError,
       });
       statusCache.invalidate({ instance: context.instance, accountId: context.accountId, repositoryId: context.repositoryId });
       return mutationReceipt(execution.record, execution.replayed, resource.providerUserId);
     }
-    const resolved = kind === 'change-request-create'
-      ? await service.resolveCreateMutation(context, context.target, normalized)
-      : await service.resolveChangeRequestMutation(context, context.target);
+    let resolved;
+    if (kind === 'change-request-create') resolved = await service.resolveCreateMutation(context, context.target, normalized);
+    else if (kind.startsWith('issue-')) resolved = await service.resolveIssueMutation(context, context.target);
+    else resolved = await service.resolveChangeRequestMutation(context, context.target);
     const execution = await options.mutationExecutor.execute({
       record: mutationRecord(context, kind, actor, credential, resolved.target, normalized.digest),
       providerAccountId: resource.providerUserId,
       perform: () => perform(service, normalized, resolved),
-      reconcile: () => reconcile(service, resolved),
+      reconcile: () => reconcile(service, resolved, normalized),
       classifyError: classifyMutationError,
     });
     statusCache.invalidate({ instance: context.instance, accountId: context.accountId, repositoryId: context.repositoryId });
@@ -785,6 +796,156 @@ export function registerGitLabRoutes(app, options = {}) {
     }
   });
 
+  // A comment or a review leaves nothing that tells a lost write from one
+  // never sent short of guessing from its text, so the outcome stays unknown.
+  const unknownOutcome = () => ({ state: 'outcome-unknown' });
+  // GitLab's own limit for a note.
+  const NOTE_MAX_LENGTH = 1_000_000;
+  const noteText = (value, required) => {
+    if (value === undefined && !required) return undefined;
+    if (!isString(value) || !value.trim() || value.length > NOTE_MAX_LENGTH) {
+      throw invalidMutationContext('body is required and must fit a GitLab note');
+    }
+    return value;
+  };
+
+  app.post('/api/source-control/gitlab/pr/comment', async (req, res) => {
+    try {
+      const body = req.body ?? {};
+      return res.json(await executeMutation(body, 'change-request-comment', (input, context) => {
+        if (!context.target.number) throw invalidMutationContext('target number is required');
+        const text = noteText(input.body, true);
+        return { body: text, digest: { body: text } };
+      }, async (service, normalized, resolved) => {
+        await service.commentChangeRequest({ providerTarget: resolved.providerTarget, body: normalized.body });
+        return {};
+      }, unknownOutcome));
+    } catch (error) {
+      return sendMutationError(res, error);
+    }
+  });
+
+  app.post('/api/source-control/gitlab/issues/comment', async (req, res) => {
+    try {
+      const body = req.body ?? {};
+      return res.json(await executeMutation(body, 'issue-comment', (input, context) => {
+        if (!context.target.number) throw invalidMutationContext('target number is required');
+        const text = noteText(input.body, true);
+        return { body: text, digest: { body: text } };
+      }, async (service, normalized, resolved) => {
+        await service.commentIssue({ providerTarget: resolved.providerTarget, body: normalized.body });
+        return {};
+      }, unknownOutcome));
+    } catch (error) {
+      return sendMutationError(res, error);
+    }
+  });
+
+  // Close or reopen: `state` is what the item should become.
+  for (const [path, kind, method] of [
+    ['/api/source-control/gitlab/pr/state', 'change-request-state', 'setChangeRequestState'],
+    ['/api/source-control/gitlab/issues/state', 'issue-state', 'setIssueState'],
+  ]) {
+    app.post(path, async (req, res) => {
+      try {
+        const body = req.body ?? {};
+        return res.json(await executeMutation(body, kind, (input, context) => {
+          if (!context.target.number || !['open', 'closed'].includes(input.state)) {
+            throw invalidMutationContext('target number and state are required');
+          }
+          return { state: input.state, digest: { state: input.state } };
+        }, (service, normalized, resolved) => service[method]({
+          state: normalized.state,
+          providerTarget: resolved.providerTarget,
+          targetProject: resolved.target.project,
+          expectedTarget: resolved.target,
+        }), (service, resolved, normalized) => service.reconcileStateMutation(resolved.providerTarget, kind, normalized.state)));
+      } catch (error) {
+        return sendMutationError(res, error);
+      }
+    });
+  }
+
+  // Labels and reviewers as one whole set, so a repeat asks for the same result.
+  const nameList = (value, limit) => {
+    if (!Array.isArray(value) || value.length > limit
+      || value.some((entry) => !isString(entry) || !entry.trim() || entry.length > 256)) {
+      throw invalidMutationContext('labels or reviewers are invalid');
+    }
+    return [...new Set(value)].sort();
+  };
+  for (const [path, kind, field, method] of [
+    ['/api/source-control/gitlab/pr/labels', 'change-request-labels', 'labels', 'setLabels'],
+    ['/api/source-control/gitlab/issues/labels', 'issue-labels', 'labels', 'setLabels'],
+    ['/api/source-control/gitlab/pr/reviewers', 'change-request-reviewers', 'reviewers', 'setReviewers'],
+  ]) {
+    app.post(path, async (req, res) => {
+      try {
+        const body = req.body ?? {};
+        return res.json(await executeMutation(body, kind, (input, context) => {
+          if (!context.target.number) throw invalidMutationContext('target number is required');
+          const names = nameList(input[field], field === 'labels' ? 100 : 50);
+          // GitLab names a reviewer by user id.
+          if (field === 'reviewers' && names.some((id) => !/^\d+$/.test(id))) throw invalidMutationContext('reviewers are invalid');
+          return { names, digest: { [field]: names } };
+        }, (service, normalized, resolved) => service[method]({
+          kind,
+          [field]: normalized.names,
+          providerTarget: resolved.providerTarget,
+          targetProject: resolved.target.project,
+          expectedTarget: resolved.target,
+        }), (service, resolved, normalized) => service.reconcileSetMutation(resolved.providerTarget, kind, normalized.names)));
+      } catch (error) {
+        return sendMutationError(res, error);
+      }
+    });
+  }
+
+  // The project's labels and who can review in it, for the board's pickers.
+  for (const [path, method] of [
+    ['/api/source-control/gitlab/references/labels', 'listLabels'],
+    ['/api/source-control/gitlab/references/reviewers', 'listReviewerCandidates'],
+  ]) {
+    app.get(path, async (req, res) => {
+      try {
+        const owner = requestText(req.query?.owner);
+        const repo = requestText(req.query?.repo);
+        if (!owner || !repo) return res.status(400).json({ error: 'a complete project selector is required' });
+        const origin = requestOrigin(req);
+        const directory = requestText(req.query?.directory);
+        const trustedContext = await validateReadContext(req, origin, directory);
+        if (!trustedContext) return res.status(501).json({ error: 'Bound source control status is unavailable' });
+        const service = await getResourceService(origin, trustedContext.accountId, true);
+        return res.json({ connected: true, items: await service[method](directory, { owner, name: repo }, trustedContext.primaryRemote) });
+      } catch (error) {
+        if (isReadContextError(error)) return res.status(error.status ?? 400).json(sourceControlErrorBody(error));
+        return sendResourceError(res, error);
+      }
+    });
+  }
+
+  app.post('/api/source-control/gitlab/pr/review', async (req, res) => {
+    try {
+      const body = req.body ?? {};
+      return res.json(await executeMutation(body, 'change-request-review', (input, context) => {
+        // A verdict names the commit it is for; without one it would land on whatever was pushed last.
+        if (!context.target.number || !context.target.headSha || !['approve', 'request-changes'].includes(input.verdict)) {
+          throw invalidMutationContext('target number, head SHA and review verdict are required');
+        }
+        const text = noteText(input.body, false);
+        return { verdict: input.verdict, body: text, digest: { verdict: input.verdict, body: text ?? null } };
+      }, (service, normalized, resolved) => service.reviewChangeRequest({
+        verdict: normalized.verdict,
+        body: normalized.body,
+        providerTarget: resolved.providerTarget,
+        targetProject: resolved.target.project,
+        expectedTarget: resolved.target,
+      }), unknownOutcome));
+    } catch (error) {
+      return sendMutationError(res, error);
+    }
+  });
+
   app.get('/api/source-control/gitlab/pulls/list', async (req, res) => {
     try {
       const origin = requestOrigin(req);
@@ -795,6 +956,7 @@ export function registerGitLabRoutes(app, options = {}) {
       return res.json(await service.listChangeRequests(directory, {
         page: requestNumber(req.query?.page) ?? 1,
         query: requestText(req.query?.query) || undefined,
+        ...readListFilter(req.query),
         remote: trustedContext.primaryRemote,
       }));
     } catch (error) {
@@ -818,7 +980,7 @@ export function registerGitLabRoutes(app, options = {}) {
       if (!number) return res.status(400).json({ error: 'number is required' });
       const service = await getResourceService(origin, trustedContext.accountId, true);
       return res.json(await service.changeRequestContext(directory, number, {
-        includeDiff: req.query?.diff === '1', includeCIDetails: req.query?.checkDetails === '1',
+        includeDiff: req.query?.diff === '1', includeCIDetails: req.query?.checkDetails === '1', includeTimeline: req.query?.timeline === '1',
         project: owner ? { owner, name: repo } : undefined,
         remote: trustedContext.primaryRemote,
         constrainToPrimary: true,
@@ -840,6 +1002,7 @@ export function registerGitLabRoutes(app, options = {}) {
       const service = await getResourceService(origin, trustedContext.accountId, true);
       return res.json(await service.listIssues(directory, {
         page: requestNumber(req.query?.page) ?? 1, query: requestText(req.query?.query) || undefined,
+        ...readListFilter(req.query),
         remote: trustedContext.primaryRemote,
       }));
     } catch (error) {
@@ -967,6 +1130,37 @@ export function registerGitLabRoutes(app, options = {}) {
       .changeRequestFileContents(context.directory, number, {
         project: projectSelector(sourceRepo), remote: context.primaryRemote, path: filePath, previousPath, status,
       })),
+    /**
+     * The account GitLab reads on this instance use when none is named: the
+     * glab login while the user has switched to it, else the active account.
+     * Null when neither is there.
+     */
+    readCurrentAccountId: async (origin) => {
+      const instance = await store.readInstance(origin);
+      // A glab login that stopped working leaves the active account, as the status read does.
+      const cli = instance.cliActive ? await getUsableGlab(origin) : null;
+      if (cli) return `${origin}#cli:${cli.user.id}`;
+      return instance.accounts.find((account) => account.id === instance.activeAccountId && account.status !== 'invalid')?.id ?? null;
+    },
+    /** A merge request's head on the context's primary project network, by number, for a worktree made from it. */
+    readChangeRequestHead: async ({ context, number }) => {
+      const trusted = await options.validateReadContext(context);
+      const service = await getResourceService(trusted.instance, trusted.accountId, true);
+      const { changeRequest: request } = await service.changeRequestContext(trusted.directory, number, {
+        remote: trusted.primaryRemote,
+        constrainToPrimary: true,
+      });
+      const headSha = String(request?.headSha || '').toLowerCase();
+      if (!request?.project || !request.head || !/^[0-9a-f]{40}$/.test(headSha)) {
+        throw Object.assign(new Error('GitLab returned an invalid merge request head'), { code: 'MALFORMED_PROVIDER_RESPONSE' });
+      }
+      return {
+        project: { id: request.project.id, owner: request.project.owner, name: request.project.name },
+        headSha,
+        headBranch: request.head,
+        headOwner: (request.headProject ?? request.project).owner,
+      };
+    },
     resolveChangeRequestSource: async ({ context, project, number, expectedHeadSha, requestedRemoteName }) => {
       const trusted = await options.validateReadContext(context);
       const service = await getResourceService(trusted.instance, trusted.accountId, true);

package/server/lib/gitlab/routes.test.js

@@ -103,6 +103,20 @@ function canonicalMutationOptions(overrides = {}) {
     ready: vi.fn(async () => ({ ready: true })),
     reconcileCreate: vi.fn(async () => ({ state: 'succeeded', result: {} })),
     reconcileExisting: vi.fn(async () => ({ state: 'outcome-unknown' })),
+    comment: vi.fn(async () => undefined),
+    commentIssue: vi.fn(async () => undefined),
+    review: vi.fn(async () => ({ commented: true })),
+    setPullState: vi.fn(async (payload) => ({ state: payload.state })),
+    setIssueState: vi.fn(async (payload) => ({ state: payload.state })),
+    reconcileState: vi.fn(async (_target, _kind, state) => ({ state: 'succeeded', result: { state } })),
+    setLabels: vi.fn(async () => ({})),
+    setReviewers: vi.fn(async () => ({})),
+    listLabels: vi.fn(async () => [{ name: 'bug', color: 'd73a4a' }]),
+    listReviewers: vi.fn(async () => [{ id: '7', login: 'ann' }]),
+    resolveIssue: vi.fn(async (context) => ({
+      providerTarget: { projectId: '2', number: context.target.number },
+      target: { repositoryId: target.repositoryId, bindingRevision: target.bindingRevision, primaryRemote: target.primaryRemote, project: target.project, number: context.target.number },
+    })),
   };
   const service = {
     resolveCreateMutation: calls.resolveCreate,
@@ -117,6 +131,18 @@ function canonicalMutationOptions(overrides = {}) {
     readyChangeRequest: calls.ready,
     reconcileCreateMutation: calls.reconcileCreate,
     reconcileChangeRequestMutation: calls.reconcileExisting,
+    commentChangeRequest: calls.comment,
+    commentIssue: calls.commentIssue,
+    reviewChangeRequest: calls.review,
+    resolveIssueMutation: calls.resolveIssue,
+    setChangeRequestState: calls.setPullState,
+    setIssueState: calls.setIssueState,
+    reconcileStateMutation: calls.reconcileState,
+    setLabels: calls.setLabels,
+    setReviewers: calls.setReviewers,
+    reconcileSetMutation: vi.fn(async () => ({ state: 'outcome-unknown' })),
+    listLabels: calls.listLabels,
+    listReviewerCandidates: calls.listReviewers,
   };
   return {
     account,
@@ -403,6 +429,104 @@ describe('GitLab routes', () => {
     expect(setup.calls.create).toHaveBeenCalledOnce();
   });
 
+  it('comments, reviews and comments on issues through the canonical executor', async () => {
+    const setup = canonicalMutationOptions();
+    const app = appWith(setup.options);
+    const existing = (key, number, extra = {}) => ({
+      ...mutationBody({ idempotencyKey: key, target: { project: { owner: 'team', name: 'repo' }, number, ...extra } }),
+    });
+
+    const commented = await request(app).post('/api/source-control/gitlab/pr/comment')
+      .send({ ...existing('comment-one', 5), body: 'Looks good' }).expect(200);
+    const reviewed = await request(app).post('/api/source-control/gitlab/pr/review')
+      .send({ ...existing('review-one', 5, { headSha: 'abc' }), verdict: 'request-changes', body: 'Rename it' }).expect(200);
+    const issue = await request(app).post('/api/source-control/gitlab/issues/comment')
+      .send({ ...existing('issue-one', 3), body: 'On it' }).expect(200);
+
+    expect(commented.body.result).toEqual({});
+    expect(reviewed.body.result).toEqual({ commented: true });
+    expect(issue.body.target).toMatchObject({ number: 3 });
+    expect(setup.calls.comment).toHaveBeenCalledWith({ providerTarget: { projectId: '2', number: 5 }, body: 'Looks good' });
+    expect(setup.calls.review).toHaveBeenCalledWith(expect.objectContaining({
+      verdict: 'request-changes', body: 'Rename it', expectedTarget: expect.objectContaining({ number: 5, headSha: 'abc' }),
+    }));
+    expect(setup.calls.commentIssue).toHaveBeenCalledWith({ providerTarget: { projectId: '2', number: 3 }, body: 'On it' });
+    expect(setup.calls.resolveIssue).toHaveBeenCalledOnce();
+
+    await request(app).post('/api/source-control/gitlab/pr/comment').send({ ...existing('comment-two', 5), body: ' ' }).expect(400);
+    await request(app).post('/api/source-control/gitlab/pr/review').send({ ...existing('review-two', 5, { headSha: 'abc' }), verdict: 'merge' }).expect(400);
+    await request(app).post('/api/source-control/gitlab/pr/review').send({ ...existing('review-three', 5), verdict: 'approve' }).expect(400);
+    expect(setup.calls.review).toHaveBeenCalledOnce();
+    expect(setup.calls.comment).toHaveBeenCalledOnce();
+  });
+
+  it('closes and reopens through the canonical executor and reconciles by state after a restart', async () => {
+    let failCompletion = false;
+    const mutationStore = makeMutationStore([], async () => {
+      if (failCompletion) {
+        failCompletion = false;
+        throw new Error('disk unavailable');
+      }
+    });
+    const setup = canonicalMutationOptions({ mutationExecutor: createMutationExecutor({ store: mutationStore }) });
+    const app = appWith(setup.options);
+    const pull = { ...mutationBody({ idempotencyKey: 'state-one', target: { project: { owner: 'team', name: 'repo' }, number: 5 } }), state: 'closed' };
+    const issue = { ...mutationBody({ idempotencyKey: 'state-two', target: { project: { owner: 'team', name: 'repo' }, number: 3 } }), state: 'open' };
+
+    const closed = await request(app).post('/api/source-control/gitlab/pr/state').send(pull).expect(200);
+    failCompletion = true;
+    await request(app).post('/api/source-control/gitlab/issues/state').send(issue).expect(409);
+    setup.options.mutationExecutor = createMutationExecutor({ store: mutationStore });
+    const recovered = await request(appWith(setup.options)).post('/api/source-control/gitlab/issues/state').send(issue).expect(200);
+    await request(app).post('/api/source-control/gitlab/pr/state').send({ ...pull, idempotencyKey: 'state-three', state: 'merged' }).expect(400);
+
+    expect(closed.body.result).toEqual({ state: 'closed' });
+    expect(recovered.body).toMatchObject({ replayed: true, result: { state: 'open' } });
+    expect(setup.calls.setPullState).toHaveBeenCalledWith(expect.objectContaining({ state: 'closed', providerTarget: { projectId: '2', number: 5 } }));
+    expect(setup.calls.setIssueState).toHaveBeenCalledOnce();
+    expect(setup.calls.reconcileState).toHaveBeenCalledWith({ projectId: '2', number: 3 }, 'issue-state', 'open');
+  });
+
+  it('sets labels and reviewers as sorted sets and reads the choices for the pickers', async () => {
+    const setup = canonicalMutationOptions();
+    const app = appWith(setup.options);
+    const target = (number) => ({ project: { owner: 'team', name: 'repo' }, number });
+
+    await request(app).post('/api/source-control/gitlab/pr/labels')
+      .send({ ...mutationBody({ idempotencyKey: 'labels-one', target: target(5) }), labels: ['docs', 'bug', 'bug'] }).expect(200);
+    await request(app).post('/api/source-control/gitlab/issues/labels')
+      .send({ ...mutationBody({ idempotencyKey: 'labels-two', target: target(3) }), labels: [] }).expect(200);
+    await request(app).post('/api/source-control/gitlab/pr/reviewers')
+      .send({ ...mutationBody({ idempotencyKey: 'reviewers-one', target: target(5) }), reviewers: ['9', '7'] }).expect(200);
+    await request(app).post('/api/source-control/gitlab/pr/reviewers')
+      .send({ ...mutationBody({ idempotencyKey: 'reviewers-two', target: target(5) }), reviewers: ['ann'] }).expect(400);
+
+    expect(setup.calls.setLabels).toHaveBeenNthCalledWith(1, expect.objectContaining({ kind: 'change-request-labels', labels: ['bug', 'docs'] }));
+    expect(setup.calls.setLabels).toHaveBeenNthCalledWith(2, expect.objectContaining({ kind: 'issue-labels', labels: [], providerTarget: { projectId: '2', number: 3 } }));
+    expect(setup.calls.setReviewers).toHaveBeenCalledOnce();
+    expect(setup.calls.setReviewers).toHaveBeenCalledWith(expect.objectContaining({ reviewers: ['7', '9'] }));
+
+    const read = { instance: origin, directory: '/repo', repositoryId: 'repo_one', accountId: `${origin}#9`, bindingRevision: 3, primaryRemote: 'origin', owner: 'team', repo: 'repo' };
+    const labels = await request(app).get('/api/source-control/gitlab/references/labels').query(read).expect(200);
+    const reviewers = await request(app).get('/api/source-control/gitlab/references/reviewers').query(read).expect(200);
+    expect(labels.body).toEqual({ connected: true, items: [{ name: 'bug', color: 'd73a4a' }] });
+    expect(reviewers.body).toEqual({ connected: true, items: [{ id: '7', login: 'ann' }] });
+    expect(setup.calls.listLabels).toHaveBeenCalledWith('/repo', { owner: 'team', name: 'repo' }, 'origin');
+  });
+
+  it('never posts a comment twice when its outcome was lost', async () => {
+    const setup = canonicalMutationOptions();
+    setup.calls.comment.mockRejectedValueOnce(Object.assign(new Error('socket closed'), { code: 'ECONNRESET' }));
+    const app = appWith(setup.options);
+    const body = { ...mutationBody({ target: { project: { owner: 'team', name: 'repo' }, number: 5 } }), body: 'Looks good' };
+
+    await request(app).post('/api/source-control/gitlab/pr/comment').send(body).expect(409);
+    const replay = await request(app).post('/api/source-control/gitlab/pr/comment').send(body).expect(409);
+
+    expect(replay.body.code).toBe('SOURCE_CONTROL_MUTATION_OUTCOME_UNKNOWN');
+    expect(setup.calls.comment).toHaveBeenCalledOnce();
+  });
+
   it('reconciles a durable create after restart without repeating the write', async () => {
     let failCompletion = true;
     const mutationStore = makeMutationStore([], async () => {
@@ -638,10 +762,11 @@ describe('GitLab routes', () => {
 
     expect(createClient).toHaveBeenCalledTimes(2);
     expect(createClient).toHaveBeenCalledWith({ origin, token: 'bound-token', tokenType: 'oauth' });
-    expect(listChangeRequests).toHaveBeenCalledWith('/repo', { page: 1, query: undefined, remote: 'upstream' });
+    expect(listChangeRequests).toHaveBeenCalledWith('/repo', { page: 1, query: undefined, state: 'open', people: 'any', remote: 'upstream' });
     expect(changeRequestContext).toHaveBeenCalledWith('/repo', 5, {
       includeDiff: true,
       includeCIDetails: true,
+      includeTimeline: false,
       project: { owner: 'team', name: 'repo' },
       remote: 'upstream',
       constrainToPrimary: true,
@@ -715,7 +840,7 @@ describe('GitLab routes', () => {
     expect(createClient).toHaveBeenCalledTimes(5);
     expect(createClient).toHaveBeenCalledWith({ origin, token: 'bound-token', tokenType: 'oauth' });
     expect(createResourceService).toHaveBeenCalledWith(expect.objectContaining({ canonicalReads: true }));
-    expect(listIssues).toHaveBeenCalledWith('/repo', { page: 2, query: 'bug', remote: 'upstream' });
+    expect(listIssues).toHaveBeenCalledWith('/repo', { page: 2, query: 'bug', state: 'open', people: 'any', remote: 'upstream' });
     expect(getIssue).toHaveBeenCalledWith('/repo', 3, { owner: 'team', name: 'repo' }, 'upstream');
     expect(issueComments).toHaveBeenCalledWith('/repo', 3, { owner: 'team', name: 'repo' }, 'upstream');
     expect(projectUpstream).toHaveBeenCalledWith('/repo', 'upstream');
@@ -1087,3 +1212,62 @@ describe('GitLab routes', () => {
     expect(active.body).toMatchObject({ connected: true, cli: { available: true, active: true } });
   });
 });
+
+
+describe('merge request head for a worktree made by number', () => {
+  const account = { id: `${origin}#2`, token: 'bound-token', user: { id: 2 }, source: 'oauth', scope: 'api', status: 'valid' };
+  const register = (changeRequest, store = makeStore(account)) => {
+    const changeRequestContext = vi.fn(async () => ({ changeRequest }));
+    const gitlab = registerGitLabRoutes(express(), {
+      authFile: '/unused/source-control-auth.json',
+      execFile: async () => ({ stdout: '' }),
+      store,
+      createClient: vi.fn(() => ({})),
+      createResourceService: vi.fn(() => ({ changeRequestContext })),
+      validateReadContext: async (context) => ({ ...context, primaryRemote: 'upstream' }),
+    });
+    return { gitlab, changeRequestContext };
+  };
+  const context = {
+    provider: 'gitlab', instance: origin, directory: '/repo', repositoryId: 'repo_one',
+    accountId: account.id, bindingRevision: 3, primaryRemote: 'upstream',
+  };
+
+  it('answers the active account, and none once it is invalid', async () => {
+    const store = makeStore(account);
+    const { gitlab } = register(null, store);
+    await expect(gitlab.readCurrentAccountId(origin)).resolves.toBe(account.id);
+    await store.markAccountInvalid(origin, account.id);
+    await expect(gitlab.readCurrentAccountId(origin)).resolves.toBeNull();
+  });
+
+  it('falls back to the active account when the glab login it was switched to stopped working', async () => {
+    const store = makeStore(account);
+    await store.setCliActive(origin, true);
+    const { gitlab } = register(null, store);
+    await expect(gitlab.readCurrentAccountId(origin)).resolves.toBe(account.id);
+  });
+
+  it('reads the target project and the fork head on the primary project network', async () => {
+    const { gitlab, changeRequestContext } = register({
+      number: 7, head: 'feature/fix', headSha: 'C'.repeat(40),
+      project: { id: '11', owner: 'team', name: 'repo' },
+      headProject: { id: '22', owner: 'alice', name: 'repo' },
+    });
+
+    await expect(gitlab.readChangeRequestHead({ context, number: 7 })).resolves.toEqual({
+      project: { id: '11', owner: 'team', name: 'repo' },
+      headSha: 'c'.repeat(40),
+      headBranch: 'feature/fix',
+      headOwner: 'alice',
+    });
+    expect(changeRequestContext).toHaveBeenCalledExactlyOnceWith('/repo', 7, { remote: 'upstream', constrainToPrimary: true });
+  });
+
+  it('refuses a merge request answer without a usable head', async () => {
+    const { gitlab } = register({ number: 7, head: 'feature/fix', headSha: '', project: { id: '11', owner: 'team', name: 'repo' } });
+
+    await expect(gitlab.readChangeRequestHead({ context, number: 7 }))
+      .rejects.toMatchObject({ code: 'MALFORMED_PROVIDER_RESPONSE' });
+  });
+});

package/server/lib/gitlab/validation.js

@@ -1,5 +1 @@
-export const isString = (value) => Object.prototype.toString.call(value) === '[object String]';
-
-export const isPlainObject = (value) => value === Object(value)
-  && !Array.isArray(value)
-  && Object.getPrototypeOf(value) === Object.prototype;
+export { isString, isPlainObject } from '../shared/guards.js';

package/server/lib/guests/DOCUMENTATION.md

@@ -46,7 +46,7 @@ Folder installs store their realpath with `source: "path"`. ZIP and Git copies l
 
 OAuth and pasted tokens live in `{openchamberDataDir}/guest-auth.json`, each entry with the `target` it was minted for (`apiOrigin`, and for OAuth `authorizeUrl` and `tokenUrl`). `takeUsableGuestAuth` runs before every use (proxy, refresh, the status card): tokens whose target differs from what the package declares now, or that carry no target, are dropped on the spot, whatever the grants say. A pending authorization carries the same target; the callback refuses the exchange (`TARGET_CHANGED`) when the package changed its endpoints in between, and the exchange itself goes to the pending target's `tokenUrl`, never to the current manifest's. The client id and secret carry their own `clientTarget`, written by `PUT /api/guests/:id/oauth/client` (`saveGuestOAuthClient`: an empty secret field keeps the stored secret only for the same client id and the same endpoints, decided under the store lock; a new id or moved endpoints drop it); `usableClientCredentials` treats a client entered for other endpoints as absent (`CLIENT_MISSING` on Connect, `hasClient: false` on the card), so a moved package gets no old secret and the user enters new credentials. Every token write that follows a network round trip (the code exchange, a refresh) goes through `patchGuestAuth` with an `expect` predicate checked under the store lock: the entry must still hold the tokens and target the round trip started from, else the answer is dropped and the entry left as it is. The proxy's cleanup after a 401 is scoped the same way: `dropGuestTokens` with an `expect` on the access token the request was refused with, so a refresh that came back empty because the user reconnected meanwhile never erases the new connection. Host Linear tokens stay in `linear-auth.json`. Writes are atomic and `0o600`. The file is per OpenChamber instance, same as `extensions.json`. Web and desktop share it. VS Code and mobile set the guest catalog to `unsupported`. That is not an empty ready list. Those cards stay hidden.
 
-A missing folder is omitted from the list. Other guests stay. A corrupt `extensions.json` is 500, not an empty catalog. A missing or blank `guest-auth.json` is an empty store. Corrupt JSON there is 500, not a disconnected card. This is not Settings → Plugins.
+A missing folder is omitted from the list. Other guests stay. The renderer reads catalog rows one by one (`packages/ui/src/lib/guests/parse.ts`): a row it cannot read, such as one from a newer server with a value this build does not know, shows in Settings → Extensions with its name and Remove, and the other rows still load. An install answered with such a row is reported as added, and the list reloads to show it. A corrupt `extensions.json` is 500, not an empty catalog. A missing or blank `guest-auth.json` is an empty store. Corrupt JSON there is 500, not a disconnected card. This is not Settings → Plugins.
 
 ## Invariants
 

package/server/lib/guests/oauth.js

@@ -10,7 +10,7 @@ import {
 
 import { dropGuestTokens, getGuestAuth, patchGuestAuth } from './auth-store.js';
 
-export const PENDING_AUTHORIZATION_TTL_MS = 10 * 60_000;
+const PENDING_AUTHORIZATION_TTL_MS = 10 * 60_000;
 
 const pendingByState = new Map();
 const pendingByGuestId = new Map();
@@ -262,7 +262,7 @@ export const storedTokensUsable = (stored, integration) => (
  * the package names now. Anything else is treated as missing.
  * @returns {{ clientId: string, clientSecret: string }}
  */
-export const usableClientCredentials = (stored, integration) => {
+const usableClientCredentials = (stored, integration) => {
   if (!sameTarget(stored?.clientTarget, credentialTarget(integration))) {
     return { clientId: '', clientSecret: '' };
   }

package/server/lib/guests/service.js

@@ -504,7 +504,7 @@ const INHERITED_SERVICE_ENV_NAMES = new Set([
 ]);
 
 /** @param {NodeJS.ProcessEnv} source */
-export const inheritedServiceEnv = (source) => {
+const inheritedServiceEnv = (source) => {
   /** @type {Record<string, string>} */
   const env = {};
   for (const [name, value] of Object.entries(source)) {

package/server/lib/guests/sockets.js

@@ -23,7 +23,7 @@ export const expandHomePath = (value, home = process.env.HOME || os.homedir()) =
  * @param {NodeJS.Platform} [platform]
  * @param {string} [home]
  */
-export const platformSocketCandidates = (
+const platformSocketCandidates = (
   binding,
   platform = process.platform,
   home = process.env.HOME || os.homedir(),

package/server/lib/injected-env.d.ts

@@ -0,0 +1,8 @@
+export const INJECTED_ENV_KEY: 'OPENCHAMBER_INJECTED_ENV';
+
+export function injectedEnvKeys(env: Record<string, string | undefined>): Set<string>;
+
+export function assignInjectedEnv<T extends Record<string, string | undefined>>(
+  env: T,
+  values: Record<string, string | undefined>,
+): T;

package/server/lib/injected-env.js

@@ -0,0 +1,50 @@
+/**
+ * Variables OpenChamber puts into an environment other processes inherit: its
+ * own host process (the desktop app, `serve --foreground`), the managed
+ * OpenCode server, and through them the integrated terminal and an agent's
+ * shell. Every such write goes through `assignInjectedEnv`, which also records
+ * the variable's name in `OPENCHAMBER_INJECTED_ENV`. A command run from one of
+ * those shells (`openchamber startup enable`) reads the record to tell
+ * OpenChamber's configuration from what the user exported, with no list of
+ * names that could drift from the code that sets them (#4604).
+ *
+ * A write that leaves the value as it was is not recorded: the shell already
+ * had that value, so it is the user's, and a user's `OPENCODE_PASSWORD` that
+ * OpenChamber passes through to the managed OpenCode stays theirs.
+ */
+
+export const INJECTED_ENV_KEY = 'OPENCHAMBER_INJECTED_ENV';
+
+/**
+ * Names recorded in `env`, plus the record itself. Empty when nothing was.
+ * @param {Record<string, string | undefined>} env
+ * @returns {Set<string>}
+ */
+export function injectedEnvKeys(env) {
+  const record = env[INJECTED_ENV_KEY] ?? '';
+  if (record.length === 0) return new Set();
+  const keys = new Set(record.split(',').filter((key) => key.length > 0));
+  keys.add(INJECTED_ENV_KEY);
+  return keys;
+}
+
+/**
+ * Set each defined value in `env` and record the names whose value changed.
+ * @template {Record<string, string | undefined>} T
+ * @param {T} env
+ * @param {Record<string, string | undefined>} values
+ * @returns {T}
+ */
+export function assignInjectedEnv(env, values) {
+  const recorded = injectedEnvKeys(env);
+  recorded.delete(INJECTED_ENV_KEY);
+  for (const [key, value] of Object.entries(values)) {
+    if (value === undefined || env[key] === value) continue;
+    env[key] = value;
+    recorded.add(key);
+  }
+  if (recorded.size > 0) {
+    env[INJECTED_ENV_KEY] = [...recorded].join(',');
+  }
+  return env;
+}