Consider it done. The open-source AI agent that works out of the box · 想到,就能做到。开源、开箱即用的 AI Agent。
TypeScript agentai-agentai-assistantandroidclaude-codecodexelectroniosllmmacosreact-nativetypescriptwindows
import {
useCallback,
useEffect,
useLayoutEffect,
useRef,
useState,
type RefObject,
} from "react";
import type { MobileMakerTransport } from "@/device-link/mobileMakerTransport";
import { withTransientRemoteRetry } from "@/device-link/remoteRetry";
import {
remoteSessionStore,
useRemoteNewMakerWorktreePreference,
} from "./remoteSessionStore";
import {
applyWorktreePreferenceOnHost,
classifyWorktreePreferenceSeed,
isWorktreeChannelNotAllowedError,
shouldBlockNewSessionCreateForWorktree,
worktreeEligibilityCaptionKey,
type NewSessionWorktreeEligibility,
} from "./newSessionWorktree";
import type { NewSessionDraft } from "./newSession";
export interface WorktreePreferenceWriteTransaction {
seq: number;
deviceId: string;
enabled: boolean;
revisionAtStart: number;
status: "writing" | "reconciling" | "committed";
}
export interface PendingWorktreePreferenceAuthority {
enabled: boolean;
revisionAtStart: number;
}
export interface WorktreeCreateIntentSnapshot {
applicable: boolean;
enabled: boolean;
target: { deviceId: string; workingDir: string };
eligibility: NewSessionWorktreeEligibility;
sourceBranch: string;
branchPreferenceKey: string;
branchPreferenceSyncKey: string;
}
export interface NewSessionWorktreeSyncInput {
selectedDeviceId: string;
connectionEpoch: number;
presenceVersion: number;
deviceLinkStatus: string;
deviceLinkStatusRef: RefObject<string>;
creating: boolean;
creatingRef: RefObject<boolean>;
draft: Pick<NewSessionDraft, "workspaceKind" | "workingDir" | "agentKind">;
maker: Pick<
MobileMakerTransport,
"getNewMakerDefaults" | "applyNewMakerWorktreePref"
>;
openLink: (deviceId: string) => Promise<unknown>;
worktreeEligibility: NewSessionWorktreeEligibility;
worktreeHostSupportsRecoveryKeyDiscard: boolean | null | undefined;
worktreeBranchPreferenceSaving: boolean;
worktreeBranchPreferenceReady: boolean;
worktreeBranchPreferenceReadyKeyRef: RefObject<string | null>;
worktreeBranchPreferenceError: boolean;
worktreeBranchPreferenceKey: string;
worktreeBranchPreferenceSyncKey: string;
worktreeBranchPreferenceSyncKeyRef: RefObject<string>;
worktreeBranchPreferenceWriteTargetRef: RefObject<string | null>;
worktreeBranchPreferenceTransactionRef: RefObject<{
key: string;
status: "writing" | "unknown" | "committed";
} | null>;
worktreeBranchTargetRef: RefObject<{ deviceId: string; workingDir: string }>;
worktreeEligibilityRef: RefObject<NewSessionWorktreeEligibility>;
worktreeSourceBranchRef: RefObject<string>;
}
/** Keep the draft's explicit choice independent of host preference writes and echoes. */
export function useNewSessionWorktreeSync({
selectedDeviceId,
connectionEpoch,
presenceVersion,
deviceLinkStatus,
deviceLinkStatusRef,
creating,
creatingRef,
draft,
maker,
openLink,
worktreeEligibility,
worktreeHostSupportsRecoveryKeyDiscard,
worktreeBranchPreferenceSaving,
worktreeBranchPreferenceReady,
worktreeBranchPreferenceReadyKeyRef,
worktreeBranchPreferenceError,
worktreeBranchPreferenceKey,
worktreeBranchPreferenceSyncKey,
worktreeBranchPreferenceSyncKeyRef,
worktreeBranchPreferenceWriteTargetRef,
worktreeBranchPreferenceTransactionRef,
worktreeBranchTargetRef,
worktreeEligibilityRef,
worktreeSourceBranchRef,
}: NewSessionWorktreeSyncInput) {
const worktreePreference =
useRemoteNewMakerWorktreePreference(selectedDeviceId);
// Defaults are advisory. A choice made in this draft wins over later host pushes.
const worktreeChoicesRef = useRef(new Map<string, boolean>());
const [, setWorktreeChoiceVersion] = useState(0);
const worktreeEnabled =
(selectedDeviceId
? worktreeChoicesRef.current.get(selectedDeviceId)
: undefined) ?? worktreePreference.enabled;
const worktreeEnabledRef = useRef(worktreeEnabled);
worktreeEnabledRef.current = worktreeEnabled;
const worktreeSeedSeqRef = useRef(0);
const [worktreeSeedRetryNonce, setWorktreeSeedRetryNonce] = useState(0);
const worktreePreferenceSyncKeyRef = useRef("");
const worktreePreferenceWriteSeqRef = useRef(0);
// Serialize writes of the next default independently of the current draft.
const worktreePreferenceWriteTargetRef = useRef<string | null>(null);
const [
worktreePreferenceSavingDeviceId,
setWorktreePreferenceSavingDeviceId,
] = useState<string | null>(null);
const worktreePreferenceTransactionRef =
useRef<WorktreePreferenceWriteTransaction | null>(null);
const worktreePreferenceRenderedRef = useRef({
deviceId: selectedDeviceId,
enabled: worktreeEnabled,
revision: worktreePreference.revision,
});
const worktreePreferenceAuthorityUnknownByDeviceRef = useRef(
new Map<string, PendingWorktreePreferenceAuthority>(),
);
const [, setWorktreePreferenceAuthorityVersion] = useState(0);
const worktreePreferenceSaving =
selectedDeviceId != null &&
(worktreePreferenceSavingDeviceId === selectedDeviceId ||
worktreePreferenceWriteTargetRef.current === selectedDeviceId);
const worktreePreferenceAwaitingEcho =
worktreePreferenceTransactionRef.current?.status === "reconciling";
const worktreePreferenceSyncKey = selectedDeviceId
? `${selectedDeviceId}\u0000${connectionEpoch}\u0000${presenceVersion}`
: "";
worktreePreferenceSyncKeyRef.current = worktreePreferenceSyncKey;
const worktreePreferenceAuthorityUnknown =
selectedDeviceId != null &&
worktreePreferenceAuthorityUnknownByDeviceRef.current.has(selectedDeviceId);
const worktreeApplicable =
draft.workspaceKind === "project" && draft.workingDir.trim().length > 0;
const worktreeToggleDisabled =
creating ||
worktreePreferenceSaving ||
(worktreeEligibility.status !== "eligible" && !worktreeEnabled);
// caption 会多占一行、把上方选择器顶起,只在它解释「已勾选但创建被拦」时显示:
// 探测中不显示;未勾选时创建不受资格影响,恢复中 / 探测失败也不显示。
const worktreeCaptionKey =
worktreeEnabled && worktreeEligibility.status !== "probing"
? worktreeEligibilityCaptionKey(worktreeEligibility)
: null;
const worktreeCreateBlocked =
shouldBlockNewSessionCreateForWorktree({
applicable: worktreeApplicable,
enabled: worktreeEnabled,
eligibility: worktreeEligibility,
// Saving a default does not change the explicit parameters of this request.
preferenceSaving: false,
}) ||
(worktreeEnabled &&
(worktreeBranchPreferenceSaving ||
(worktreeEligibility.status === "eligible" &&
!worktreeBranchPreferenceReady) ||
(worktreeBranchPreferenceTransactionRef.current?.key ===
worktreeBranchPreferenceKey &&
worktreeBranchPreferenceTransactionRef.current.status ===
"unknown")));
const worktreeControlCaptionKey =
worktreeCaptionKey ??
(worktreePreferenceAuthorityUnknown
? "session.new.worktreeSettingsSyncFailed"
: null) ??
(worktreeBranchPreferenceError
? "session.new.worktreeBranchSyncFailed"
: null);
const resolveWorktreeCreateErrorKey = useCallback(
() =>
worktreeEligibilityCaptionKey(worktreeEligibilityRef.current) ??
(worktreeBranchPreferenceError
? "session.new.worktreeBranchSyncFailed"
: "session.new.worktreeBranchSaving"),
[worktreeBranchPreferenceError],
);
useLayoutEffect(() => {
worktreePreferenceRenderedRef.current = {
deviceId: selectedDeviceId,
enabled: worktreePreference.enabled,
revision: worktreePreference.revision,
};
const transaction = worktreePreferenceTransactionRef.current;
if (
!transaction ||
(transaction.status !== "reconciling" &&
transaction.status !== "committed") ||
transaction.deviceId !== selectedDeviceId ||
worktreePreference.enabled !== transaction.enabled ||
worktreePreference.revision <= transaction.revisionAtStart
)
return;
worktreePreferenceTransactionRef.current = null;
if (worktreePreferenceWriteTargetRef.current === transaction.deviceId) {
worktreePreferenceWriteTargetRef.current = null;
}
setWorktreePreferenceSavingDeviceId(null);
}, [
selectedDeviceId,
worktreePreference.enabled,
worktreePreference.revision,
worktreePreferenceAwaitingEcho,
]);
useEffect(() => {
if (!selectedDeviceId) return;
const transaction = worktreePreferenceTransactionRef.current;
if (
transaction?.deviceId === selectedDeviceId &&
transaction.status === "reconciling" &&
worktreePreference.revision > transaction.revisionAtStart &&
worktreePreference.enabled !== transaction.enabled
) {
// The host echoed a different authoritative value. Do not silently use
// it for this Create attempt: release the active spinner, retain the
// user's requested value as an unknown obligation, and allow a retry.
worktreePreferenceAuthorityUnknownByDeviceRef.current.set(
selectedDeviceId,
{
enabled: transaction.enabled,
revisionAtStart: transaction.revisionAtStart,
},
);
worktreePreferenceTransactionRef.current = null;
if (worktreePreferenceWriteTargetRef.current === selectedDeviceId) {
worktreePreferenceWriteTargetRef.current = null;
}
setWorktreePreferenceSavingDeviceId(null);
setWorktreePreferenceAuthorityVersion((value) => value + 1);
}
const pending =
worktreePreferenceAuthorityUnknownByDeviceRef.current.get(
selectedDeviceId,
);
if (
!pending ||
worktreePreference.revision <= pending.revisionAtStart ||
worktreePreference.enabled !== pending.enabled
)
return;
worktreePreferenceAuthorityUnknownByDeviceRef.current.delete(
selectedDeviceId,
);
setWorktreePreferenceAuthorityVersion((value) => value + 1);
}, [
selectedDeviceId,
worktreePreference.enabled,
worktreePreference.revision,
worktreePreferenceAwaitingEcho,
]);
const captureWorktreeCreateIntent =
useCallback((): WorktreeCreateIntentSnapshot => {
const target = { ...worktreeBranchTargetRef.current };
const eligibility = worktreeEligibilityRef.current;
const branchPreferenceKey =
target.deviceId && eligibility.status === "eligible"
? `${target.deviceId}\u0000${eligibility.baseRepo}`
: "";
return {
applicable:
target.deviceId.length > 0 && target.workingDir.trim().length > 0,
enabled: worktreeEnabledRef.current,
target,
eligibility,
sourceBranch: worktreeSourceBranchRef.current,
branchPreferenceKey,
branchPreferenceSyncKey: worktreeBranchPreferenceSyncKeyRef.current,
};
}, []);
const isWorktreeCreateIntentCurrent = useCallback(
(intent: WorktreeCreateIntentSnapshot): boolean => {
if (!intent.applicable) return true;
const currentTarget = worktreeBranchTargetRef.current;
if (
deviceLinkStatusRef.current !== "online" ||
currentTarget.deviceId !== intent.target.deviceId ||
currentTarget.workingDir.trim() !== intent.target.workingDir.trim()
)
return false;
// ineligible 目标不创建 worktree,无需等偏好同步/就绪——提前返回,
// 避免偏好 GET 在途时被下方偏好守卫拦截;与 enabled 无关(2026-08-07 裁决)。
// 但快照不能替代实时状态:await 期间同目标可能被重探回 probing/eligible/
// detect-failed,旧 ineligible 快照必须复核 live ref 仍为 ineligible 才放行,
// 否则回到 fail closed(探测未定不等于确认不合格)。
if (!intent.enabled) return true;
if (intent.eligibility.status === "ineligible") {
return worktreeEligibilityRef.current.status === "ineligible";
}
// The click captures the displayed choice. Background defaults and persistence
// ACKs cannot invalidate an already submitted request.
// ineligible 已在前面提前返回,此处只可能是 eligible(2026-08-07 裁决)。
if (intent.eligibility.status !== "eligible") return false;
// 与 ineligible 快照同理:eligible 快照也必须复核 live 资格仍是同一 repo 的
// eligible,await 期间被重探成别的状态或换了 repo 都不能继续建 worktree。
const currentEligibility = worktreeEligibilityRef.current;
if (
currentEligibility.status !== "eligible" ||
currentEligibility.baseRepo !== intent.eligibility.baseRepo
)
return false;
const branchTransaction = worktreeBranchPreferenceTransactionRef.current;
// A missing branch snapshot may only be a pending read, not host consent
// to use the detected branch. Checkbox defaults remain independent.
return (
worktreeBranchPreferenceReadyKeyRef.current ===
intent.branchPreferenceSyncKey &&
worktreeBranchPreferenceSyncKeyRef.current ===
intent.branchPreferenceSyncKey &&
worktreeBranchPreferenceWriteTargetRef.current !==
intent.branchPreferenceKey &&
!(
branchTransaction?.key === intent.branchPreferenceKey &&
(branchTransaction.status === "writing" ||
branchTransaction.status === "unknown")
)
);
},
[],
);
// —— worktree 勾选播种:选中设备后读工作端 get-new-maker-defaults 的 worktreeEnabled
// (vendor 无关,agentKind 只是通道入参,经 ref 读当前值,不因切 agent 重播)。
// 设备切换 / 链路重连重新播种;老被控端 / 缺字段 / 拉取失败只保留当前镜像。
// 全新设备在 store 中没有镜像时本来就是默认未勾选,无需失败路径代替宿主写值。
const worktreeSeedAgentKindRef = useRef(draft.agentKind);
worktreeSeedAgentKindRef.current = draft.agentKind;
// Read the host capability through a ref: probing a different directory must
// not cancel a device-wide defaults request. Old hosts need no missing-field retry.
const worktreeHostSupportsRecoveryKeyDiscardRef = useRef(
worktreeHostSupportsRecoveryKeyDiscard,
);
worktreeHostSupportsRecoveryKeyDiscardRef.current =
worktreeHostSupportsRecoveryKeyDiscard;
useEffect(() => {
const seq = ++worktreeSeedSeqRef.current;
const syncKey = worktreePreferenceSyncKey;
if (!selectedDeviceId || !syncKey || deviceLinkStatus !== "online")
return undefined;
const preferenceRevisionAtStart =
remoteSessionStore.getNewMakerWorktreePreference(
selectedDeviceId,
).revision;
let cancelled = false;
let retryTimer: ReturnType<typeof setTimeout> | null = null;
const scheduleRetry = () => {
if (retryTimer) return;
retryTimer = setTimeout(() => {
if (!cancelled) setWorktreeSeedRetryNonce((value) => value + 1);
}, 1_500);
};
// 与上面 detect effect 同款:先建链再拉,包瞬态重试——app 后台恢复时 relay 常在
// 重连窗口,裸调会抛 NOT_CONNECTED 并把工作端持久化的勾选偏好静默播种成未勾。
void withTransientRemoteRetry(
async () => {
await openLink(selectedDeviceId);
return maker.getNewMakerDefaults(worktreeSeedAgentKindRef.current);
},
{ maxAttempts: 2 },
)
.then((defaults) => {
if (
cancelled ||
seq !== worktreeSeedSeqRef.current ||
worktreePreferenceSyncKeyRef.current !== syncKey
)
return;
// 请求发出后若已收到更晚的 push / 用户点击,旧 pull 不再有覆盖权。
if (
remoteSessionStore.getNewMakerWorktreePreference(selectedDeviceId)
.revision !== preferenceRevisionAtStart
)
return;
const classification = classifyWorktreePreferenceSeed(defaults);
if (classification.status === "ready") {
// Update only the host mirror. Explicit draft choices remain separate.
remoteSessionStore.setNewMakerWorktreePreference(
selectedDeviceId,
classification.enabled,
);
return;
}
if (
classification.status === "missing" &&
worktreeHostSupportsRecoveryKeyDiscardRef.current === false
) {
// Old hosts cannot persist this preference and also lack the recovery
// capability marker. A new host can transiently return `{}` before its
// renderer cache arrives; keep the last mirror and retry in that case.
return;
}
scheduleRetry();
})
.catch((error: unknown) => {
if (
cancelled ||
seq !== worktreeSeedSeqRef.current ||
worktreePreferenceSyncKeyRef.current !== syncKey
)
return;
if (isWorktreeChannelNotAllowedError(error)) {
return;
}
// A failed defaults read leaves the displayed value usable for creation.
scheduleRetry();
});
return () => {
cancelled = true;
if (retryTimer) clearTimeout(retryTimer);
};
}, [
connectionEpoch,
deviceLinkStatus,
presenceVersion,
selectedDeviceId,
worktreePreferenceSyncKey,
worktreeSeedRetryNonce,
maker,
openLink,
]);
// Saving the next default is independent of using this draft's explicit choice.
// An accepted write may never echo back; release the control after 10 seconds.
useEffect(() => {
if (!worktreePreferenceSavingDeviceId || !worktreePreferenceAwaitingEcho)
return;
const transaction = worktreePreferenceTransactionRef.current;
const timer = setTimeout(() => {
if (
!transaction ||
worktreePreferenceTransactionRef.current !== transaction
)
return;
worktreePreferenceAuthorityUnknownByDeviceRef.current.set(
transaction.deviceId,
{
enabled: transaction.enabled,
revisionAtStart: transaction.revisionAtStart,
},
);
worktreePreferenceTransactionRef.current = null;
worktreePreferenceWriteTargetRef.current = null;
setWorktreePreferenceSavingDeviceId(null);
setWorktreePreferenceAuthorityVersion((value) => value + 1);
}, 10_000);
return () => clearTimeout(timer);
}, [worktreePreferenceSavingDeviceId, worktreePreferenceAwaitingEcho]);
// 用户显式点击开关:先写工作端,工作端接受后才更新手机内存镜像。
// 资格不满足导致的禁用不会走到这里 —— 环境因素不抹掉用户偏好;
// 写入失败也不在手机上制造一份假的持久状态。
const toggleWorktree = useCallback(() => {
if (
creatingRef.current ||
!selectedDeviceId ||
worktreePreferenceSaving ||
worktreePreferenceWriteTargetRef.current === selectedDeviceId
)
return;
const targetDeviceId = selectedDeviceId;
const next = !worktreeEnabledRef.current;
worktreeChoicesRef.current.set(targetDeviceId, next);
worktreeEnabledRef.current = next;
setWorktreeChoiceVersion((value) => value + 1);
// 播种在途回包不得覆盖用户显式选择(seq 作废旧回包)。
worktreeSeedSeqRef.current += 1;
const preferenceRevisionAtStart =
remoteSessionStore.getNewMakerWorktreePreference(targetDeviceId).revision;
const writeSeq = worktreePreferenceWriteSeqRef.current + 1;
worktreePreferenceWriteSeqRef.current = writeSeq;
if (
worktreePreferenceAuthorityUnknownByDeviceRef.current.delete(
targetDeviceId,
)
) {
setWorktreePreferenceAuthorityVersion((value) => value + 1);
}
const transaction: WorktreePreferenceWriteTransaction = {
seq: writeSeq,
deviceId: targetDeviceId,
enabled: next,
revisionAtStart: preferenceRevisionAtStart,
status: "writing",
};
// Switching devices may replace a write that is still awaiting ACK/echo.
// Preserve its uncertainty in the existing per-device reconciliation map.
const previousTransaction = worktreePreferenceTransactionRef.current;
if (
previousTransaction &&
previousTransaction.deviceId !== targetDeviceId
) {
worktreePreferenceAuthorityUnknownByDeviceRef.current.set(
previousTransaction.deviceId,
{
enabled: previousTransaction.enabled,
revisionAtStart: previousTransaction.revisionAtStart,
},
);
setWorktreePreferenceAuthorityVersion((value) => value + 1);
}
worktreePreferenceTransactionRef.current = transaction;
// Serialize preference writes; Create/Goal use the synchronous draft choice above.
worktreePreferenceWriteTargetRef.current = targetDeviceId;
setWorktreePreferenceSavingDeviceId(targetDeviceId);
const releaseWrite = () => {
if (worktreePreferenceWriteSeqRef.current !== writeSeq) return;
if (worktreePreferenceTransactionRef.current?.seq === writeSeq) {
worktreePreferenceTransactionRef.current = null;
}
if (worktreePreferenceWriteTargetRef.current === targetDeviceId) {
worktreePreferenceWriteTargetRef.current = null;
}
setWorktreePreferenceSavingDeviceId(null);
};
const markAuthorityUnknown = () => {
if (worktreePreferenceWriteSeqRef.current !== writeSeq) return;
worktreePreferenceAuthorityUnknownByDeviceRef.current.set(
targetDeviceId,
{
enabled: next,
revisionAtStart: preferenceRevisionAtStart,
},
);
setWorktreePreferenceAuthorityVersion((value) => value + 1);
releaseWrite();
setWorktreeSeedRetryNonce((value) => value + 1);
};
const armCommittedRender = () => {
if (worktreePreferenceWriteSeqRef.current !== writeSeq) return;
transaction.status = "committed";
const rendered = worktreePreferenceRenderedRef.current;
if (
rendered.deviceId === targetDeviceId &&
rendered.enabled === next &&
rendered.revision > preferenceRevisionAtStart
)
releaseWrite();
};
void (async () => {
try {
const outcome = await applyWorktreePreferenceOnHost({
enabled: next,
apply: maker.applyNewMakerWorktreePref,
// unsupported 可能是“有偏好写穿、缺安全 worktree 能力”,也可能是最老端
// 连偏好 channel 都没有:先写 host;只有后者且用户明确点 OFF 时才清手机
// 保留的旧 ON 镜像。断连/超时不降级,仍保留 ON + fail closed。
allowUnsupportedDisableFallback:
!next && worktreeEligibility.status === "unsupported",
mirror: (enabled) => {
if (worktreePreferenceWriteSeqRef.current !== writeSeq) return;
const current =
remoteSessionStore.getNewMakerWorktreePreference(targetDeviceId);
if (current.revision === preferenceRevisionAtStart) {
remoteSessionStore.setNewMakerWorktreePreference(
targetDeviceId,
enabled,
);
}
const accepted =
remoteSessionStore.getNewMakerWorktreePreference(targetDeviceId);
if (
accepted.revision > preferenceRevisionAtStart &&
accepted.enabled === enabled
) {
armCommittedRender();
} else {
markAuthorityUnknown();
}
},
});
if (worktreePreferenceWriteSeqRef.current !== writeSeq) return;
if (outcome === "accepted") {
// Main acknowledged the broadcast; track persistence separately from creation.
transaction.status = "reconciling";
setWorktreeSeedRetryNonce((value) => value + 1);
}
} catch (error) {
if (worktreePreferenceWriteSeqRef.current !== writeSeq) return;
if (isWorktreeChannelNotAllowedError(error)) {
// Explicit old-channel rejection proves this ON request did not
// commit. Keep the rendered value and let the user continue.
releaseWrite();
return;
}
// Lost ACK / disconnect may have committed remotely. Reconcile the default
// via push/GET, while the explicit draft choice remains usable.
markAuthorityUnknown();
}
})();
}, [
maker,
selectedDeviceId,
worktreeEnabled,
worktreePreferenceSaving,
worktreeEligibility.status,
]);
const prepareWorktreeCreateIntent = useCallback(
(
onError: (key: string) => void,
): WorktreeCreateIntentSnapshot | undefined => {
const intent = captureWorktreeCreateIntent();
if (!isWorktreeCreateIntentCurrent(intent)) {
onError(resolveWorktreeCreateErrorKey());
return undefined;
}
return intent;
},
[
captureWorktreeCreateIntent,
isWorktreeCreateIntentCurrent,
resolveWorktreeCreateErrorKey,
],
);
return {
worktreeEnabled,
worktreeApplicable,
worktreeToggleDisabled,
worktreeCreateBlocked,
worktreeCaptionKey,
worktreeControlCaptionKey,
resolveWorktreeCreateErrorKey,
captureWorktreeCreateIntent,
isWorktreeCreateIntentCurrent,
toggleWorktree,
worktreePreferenceSaving,
worktreePreferenceAuthorityUnknown,
prepareWorktreeCreateIntent,
};
}