feat(composer): workspace picker, git branch switching, and composer defaults persistence

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});

apps/desktop/src/global.d.ts

@@ -436,6 +436,27 @@ declare global {
  | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
  | { ok: false; reason: 'cancelled' | 'missing-selection' }
  >;
+ selectProjectRoot(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ resolveProjectGitInfo(projectPath: string): Promise<
+ | { ok: true; projectPath: string; projectGit: { isGitRepo: boolean; branch?: string } }
+ | { ok: false; reason: 'invalid-path' | 'not-found' }
+ >;
+ listGitBranches(): Promise<{
+ ok: boolean;
+ branches?: string[];
+ current?: string;
+ reason?: string;
+ message?: string;
+ }>;
+ checkoutGitBranch(branch: string): Promise<{
+ ok: boolean;
+ branch?: string;
+ reason?: string;
+ message?: string;
+ }>;
  openArtifactPath(
  artifactId: string,
  ): Promise<

apps/desktop/src/main/__tests__/bot-incoming-project-cwd.test.ts

@@ -0,0 +1,67 @@
+import { strict as assert } from 'node:assert';
+import { describe, it } from 'node:test';
+import type { BotIncomingMessage, BotRegistry, SessionManager } from '@maka/runtime';
+import { createBotIncomingMainService } from '../bot-incoming-main.js';
+
+describe('bot incoming new-session cwd', () => {
+ it('creates the bot session with the current project root, not process.cwd()', async () => {
+ let capturedCwd: unknown = undefined;
+ let resolveCreated: () => void = () => {};
+ const created = new Promise<void>((resolve) => {
+ resolveCreated = resolve;
+ });
+ const service = createBotIncomingMainService({
+ // createSession captures the cwd it was given, signals the test, then
+ // throws to short-circuit before the streaming / typing path runs.
+ runtime: {
+ async createSession(input: { cwd?: unknown }) {
+ capturedCwd = input.cwd;
+ resolveCreated();
+ throw new Error('__short_circuit_after_create__');
+ },
+ } as unknown as SessionManager,
+ botRegistry: {
+ async sendMessage() {},
+ async sendTypingIndicator() {
+ return false;
+ },
+ isImplemented() {
+ return true;
+ },
+ } as unknown as BotRegistry,
+ getCurrentProjectRoot: async () => '/custom/project/root',
+ getDefaultConnectionSlug: async () => 'slug',
+ getReadyConnection: async () => ({ connection: { slug: 'slug' }, model: 'm' }),
+ readSessionHeader: async () => ({ permissionMode: 'ask' }),
+ ensureSessionCanSend: async () => {},
+ emitSessionsChanged() {},
+ sendToRenderer() {},
+ isStatusChangingSessionEvent() {
+ return false;
+ },
+ isTurnStatusChangingSessionEvent() {
+ return false;
+ },
+ });
+
+ await service.handleBotIncomingMessage({
+ platform: 'telegram',
+ userId: 'u',
+ userName: 'U',
+ chatId: 'c1',
+ isGroup: false,
+ text: 'hello',
+ sourceMessageId: '',
+ receivedAt: Date.now(),
+ } as unknown as BotIncomingMessage);
+
+ // handleBotIncomingMessage returns before the queued create runs; wait
+ // for createSession to actually be invoked (or time out).
+ await Promise.race([
+ created,
+ new Promise<void>((_, reject) => setTimeout(() => reject(new Error('createSession was not called')), 1000)),
+ ]);
+
+ assert.equal(capturedCwd, '/custom/project/root');
+ });
+});

apps/desktop/src/main/__tests__/composer-new-chat-model-picker-contract.test.ts

@@ -99,8 +99,8 @@ describe('home composer new-chat model picker', () => {
  );
  assert.match(
  renderer,
- /onPickNewChatModel=\{\(input\) => setPendingNewChatModel\(input\)\}/,
- 'main.tsx must wire the composer pick to setPendingNewChatModel',
+ /onPickNewChatModel=\{\(input\) => \{[\s\S]*setPendingNewChatModel\(input\);[\s\S]*saveComposerDefaults\(\{ model: input \}\);[\s\S]*\}\}/,
+ 'main.tsx must wire the composer pick to state and persisted composer defaults',
  );
  // A pick only stays in effect while it is still an offered choice; once the
  // connection/model is removed the picker must fall back to the default so it
@@ -150,7 +150,22 @@ describe('home composer new-chat model picker', () => {
  assert.match(
  renderer,
  /const \[pendingNewChatPermissionMode, setPendingNewChatPermissionMode\] = useState<PermissionMode \| null>\(null\)/,
- 'AppShell must keep the picked empty-state permission mode in renderer-only state',
+ 'AppShell must keep the no-session permission pick renderer-only and start it from null',
+ );
+ assert.doesNotMatch(
+ renderer,
+ /saveComposerDefaults\(\{\s*permissionMode:/,
+ 'permission mode must not be persisted into composer defaults',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode: \(mode: PendingNewChatPermissionMode\) => void;/,
+ 'createAppShellChatActions deps must include setPendingNewChatPermissionMode so send() can reset the one-shot pick',
+ );
+ assert.match(
+ renderer,
+ /setPendingNewChatPermissionMode,[\s\S]*validPendingNewChatModel,/,
+ 'createAppShellChatActions must destructure setPendingNewChatPermissionMode before send() calls it',
  );
  assert.match(
  setPermissionModeBlock,

apps/desktop/src/main/__tests__/git-branch.test.ts

@@ -0,0 +1,231 @@
+import { strict as assert } from 'node:assert';
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { describe, it } from 'node:test';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import type { ExecFileException } from 'node:child_process';
+import { listLocalBranches, checkoutBranch } from '../git-branch.js';
+
+type ExecFileCallback = (
+ file: string,
+ args: readonly string[],
+ options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+) => void;
+
+function fakeExecFile(onExecute: (args: readonly string[]) => {
+ error: ExecFileException | null;
+ stdout: string;
+ stderr: string;
+}): ExecFileCallback {
+ return (
+ _file: string,
+ args: readonly string[],
+ _options: { cwd: string; timeout: number; windowsHide: boolean },
+ cb: (error: ExecFileException | null, stdout: string, stderr: string) => void,
+ ) => {
+ const result = onExecute(args);
+ cb(result.error, result.stdout, result.stderr);
+ };
+}
+
+function errnoException(code: string, message?: string): ExecFileException {
+ const err = new Error(message ?? code) as NodeJS.ErrnoException & ExecFileException;
+ err.code = code;
+ err.name = 'Error';
+ return err as unknown as ExecFileException;
+}
+
+async function withGitRepo(run: (gitRoot: string) => Promise<void>): Promise<void> {
+ const root = await mkdtemp(join(tmpdir(), 'maka-git-test-'));
+ await mkdir(join(root, '.git'), { recursive: true });
+ await writeFile(join(root, '.git', 'HEAD'), 'ref: refs/heads/main\n', 'utf8');
+ try {
+ await run(root);
+ } finally {
+ await rm(root, { recursive: true, force: true });
+ }
+}
+
+describe('listLocalBranches', () => {
+ it('parses `git branch --list` output with current branch marked by *', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile((args) => {
+ assert.deepEqual(args, ['branch', '--list']);
+ return { error: null, stdout: '* main\n develop\n feature/sidebar\n', stderr: '' };
+ });
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop', 'feature/sidebar']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('detects detached HEAD (no * branch)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* (HEAD detached at abc1234)\n main\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, undefined);
+ });
+ });
+
+ it('handles a single-branch repo', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('deduplicates branch names', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: null,
+ stdout: '* main\n develop\n develop\n',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, true);
+ assert.deepEqual(result.branches, ['main', 'develop']);
+ assert.equal(result.current, 'main');
+ });
+ });
+
+ it('returns not-a-repo when project lacks .git metadata', async () => {
+ const result = await listLocalBranches('/tmp/non-existent');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'not-a-repo');
+ });
+
+ it('returns missing-git when git binary is not found (ENOENT)', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: errnoException('ENOENT', 'spawn git ENOENT'),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'missing-git');
+ });
+ });
+
+ it('returns timeout when git takes too long', async () => {
+ await withGitRepo(async (root) => {
+ const execFileImpl = fakeExecFile(() => ({
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ }));
+ const result = await listLocalBranches(root, { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ });
+ });
+});
+
+describe('checkoutBranch', () => {
+ it('switches to a valid branch and returns the new branch name', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.ok(result.ok);
+ assert.deepEqual(gitCalls, [
+ ['status', '--porcelain'],
+ ['checkout', 'develop'],
+ ]);
+ });
+ });
+
+ it('rejects invalid branch names', async () => {
+ const result = await checkoutBranch('/fake/repo', 'bad; branch');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.match(result.message ?? '', /无效的分支名/);
+ });
+
+ it('rejects empty branch name', async () => {
+ const result = await checkoutBranch('/fake/repo', '');
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ });
+
+ it('refuses checkout when worktree is dirty', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return { error: null, stdout: 'M index.ts\n', stderr: '' };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'dirty');
+ assert.equal(result.message, '工作区有未提交的更改，请先提交或暂存。');
+ // The only git command that was run was `git status --porcelain`;
+ // `git checkout` must NOT be called on a dirty worktree.
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command fails', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: errnoException('EACCES', 'status failed'),
+ stdout: '',
+ stderr: 'fatal: cannot inspect worktree',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'failed');
+ assert.equal(result.message, 'fatal: cannot inspect worktree');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+
+ it('fails closed when dirty-check status command times out', async () => {
+ await withGitRepo(async (root) => {
+ const gitCalls: string[][] = [];
+ const execFileImpl = fakeExecFile((args) => {
+ gitCalls.push([...args]);
+ if (args[0] === 'status' && args[1] === '--porcelain') {
+ return {
+ error: Object.assign(errnoException('ETIMEDOUT', 'timeout'), { killed: true }),
+ stdout: '',
+ stderr: '',
+ };
+ }
+ return { error: null, stdout: '', stderr: '' };
+ });
+ const result = await checkoutBranch(root, 'develop', { execFileImpl });
+ assert.equal(result.ok, false);
+ assert.equal(result.reason, 'timeout');
+ assert.deepEqual(gitCalls, [['status', '--porcelain']]);
+ });
+ });
+});