@adhdev/daemon-core 0.9.82-rc.45 → 0.9.82-rc.451

package/src/commands/chat-commands-scope.ts

@@ -0,0 +1,54 @@
+/**
+ * Chat Commands — read_chat node workspace scope guard.
+ */
+
+import type { CommandHelpers } from './handler.js';
+import { normalizeMeshWorkspaceForCompare } from '@adhdev/mesh-shared';
+import { getTargetInstance } from './chat-commands-shared.js';
+
+/**
+ * read_chat node scope verdict. One physical daemon hosts a base node plus several
+ * worktree nodes; mesh_read_chat always dispatches read_chat with the requested
+ * node's workspace (`args.workspace`). When the resolved target session actually
+ * lives in a DIFFERENT worktree, returning its transcript — or worse, letting the
+ * native-history-by-workspace fallback splice sibling worktree turns into the
+ * reply — makes the coordinator believe one session received every worktree's
+ * work. This guard refuses a CONFIRMED cross-workspace read instead of mixing.
+ *
+ * Conservative by design (mirrors the WTCLAIM fix-B "unknown → allow" rule): only
+ * a session id that resolves to a known workspace which is unequal to a known
+ * intended workspace blocks. When either side is unknown — no targetSessionId, no
+ * args.workspace, an unregistered session, the coordinator self-session, or a
+ * plain dashboard read that never passes a node workspace — the read proceeds
+ * untouched, so base-node and same-daemon coordinator reads never regress.
+ */
+export function evaluateReadChatNodeWorkspaceScope(args: {
+    targetSessionId?: string;
+    intendedWorkspace?: string;
+    sessionWorkspace?: string;
+}): { scoped: false } | { scoped: true; intended: string; actual: string } {
+    const targetSessionId = typeof args.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+    if (!targetSessionId) return { scoped: false };
+    const intended = normalizeMeshWorkspaceForCompare(args.intendedWorkspace);
+    const actual = normalizeMeshWorkspaceForCompare(args.sessionWorkspace);
+    if (!intended || !actual) return { scoped: false };
+    if (intended === actual) return { scoped: false };
+    return { scoped: true, intended, actual };
+}
+
+/**
+ * Resolve the target session's ACTUAL workspace from the most authoritative source
+ * available on this daemon: the session registry record (stamped at register
+ * time), then the live CLI adapter's working directory, then the bound instance
+ * state. Returns '' when nothing knows the session's workspace — the caller treats
+ * that as "unknown" and does not block.
+ */
+export function resolveTargetSessionActualWorkspace(h: CommandHelpers, targetSessionId: string): string {
+    const registryWorkspace = (h.ctx?.sessionRegistry?.get?.(targetSessionId) as any)?.workspace;
+    if (typeof registryWorkspace === 'string' && registryWorkspace.trim()) return registryWorkspace;
+    const adapter = h.getCliAdapter?.(targetSessionId);
+    if (adapter && typeof adapter.workingDir === 'string' && adapter.workingDir.trim()) return adapter.workingDir;
+    const instanceWorkspace = (getTargetInstance(h, { targetSessionId })?.getState?.() as any)?.workspace;
+    if (typeof instanceWorkspace === 'string' && instanceWorkspace.trim()) return instanceWorkspace;
+    return '';
+}

package/src/commands/chat-commands-shared.ts

@@ -0,0 +1,114 @@
+/**
+ * Chat Commands — shared private helpers used by more than one handler group.
+ *
+ * These were module-local helpers/consts/interfaces in chat-commands.ts. They
+ * are exported here only so the split read/write/debug/scope sub-modules can
+ * import them; they are NOT part of the public chat-commands surface (except
+ * READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS and buildSendInputSignature, which the
+ * chat-commands barrel re-exports).
+ */
+
+import type { CommandHelpers } from './handler.js';
+import type { CliAdapter } from '../cli-adapter-types.js';
+import { type InputEnvelope, type ProviderModule } from '../providers/contracts.js';
+import type { ProviderInstance } from '../providers/provider-instance.js';
+import { buildChatMessageSignature, hashSignatureParts } from '../chat/chat-signatures.js';
+import type { ChatMessage } from '../types.js';
+import type { SessionTransport } from '../shared-types.js';
+
+export const READ_CHAT_PROVIDER_EVAL_TIMEOUT_MS = 25_000;
+
+export interface ApprovalSelectableInstance extends ProviderInstance {
+    recordApprovalSelection?(buttonText: string): void;
+}
+
+export interface RuntimeChatMessageMerger extends ProviderInstance {
+    mergeRuntimeChatMessages?(messages: ChatMessage[]): ChatMessage[];
+    recordAcknowledgedUserInput?(input: InputEnvelope | string): void;
+}
+
+export function getCurrentProviderType(h: CommandHelpers, fallback = ''): string {
+    return h.currentSession?.providerType || h.currentProviderType || fallback;
+}
+
+export function getCurrentManagerKey(h: CommandHelpers): string {
+    return h.currentSession?.cdpManagerKey || h.currentManagerKey || '';
+}
+
+export function getTargetedCliAdapter(h: CommandHelpers, args: any, providerType?: string): CliAdapter | null {
+    return h.getCliAdapter(args?.targetSessionId || providerType || h.currentSession?.providerType || h.currentManagerKey);
+}
+
+export function getTargetInstance(h: CommandHelpers, args: any): ApprovalSelectableInstance | null {
+    const targetSessionId = typeof args?.targetSessionId === 'string' ? args.targetSessionId.trim() : '';
+    const sessionId = targetSessionId || h.currentSession?.sessionId || '';
+    if (!sessionId) return null;
+    const session = h.ctx.sessionRegistry?.get(sessionId);
+    const instanceKey = session?.adapterKey || session?.instanceKey || sessionId;
+    return (h.ctx.instanceManager?.getInstance(instanceKey) as ApprovalSelectableInstance | undefined) || null;
+}
+
+export function getTargetTransport(h: CommandHelpers, provider?: ProviderModule): SessionTransport | null {
+    if (h.currentSession?.transport) return h.currentSession.transport;
+    switch (provider?.category) {
+        case 'cli':
+            return 'pty';
+        case 'acp':
+            return 'acp';
+        case 'extension':
+            return 'cdp-webview';
+        case 'ide':
+            return 'cdp-page';
+        default:
+            return null;
+    }
+}
+
+export function isCliLikeTransport(transport: SessionTransport | null): boolean {
+    return transport === 'pty' || transport === 'acp';
+}
+
+export function isExtensionTransport(transport: SessionTransport | null): boolean {
+    return transport === 'cdp-webview';
+}
+
+function summarizeSendInputPart(part: any): string {
+    if (!part || typeof part !== 'object') return String(part ?? '');
+    if (part.type === 'text') return `text:${String(part.text || '').trim()}`;
+    const fields = [
+        `type=${String(part.type || '')}`,
+        `mime=${String(part.mimeType || '')}`,
+        `uri=${String(part.uri || '')}`,
+        `name=${String(part.name || '')}`,
+    ];
+    const data = typeof part.data === 'string'
+        ? part.data
+        : typeof part.resource?.blob === 'string'
+            ? part.resource.blob
+            : '';
+    if (data) fields.push(`dataLen=${data.length}`, `dataHash=${hashSignatureParts([data]).slice(0, 12)}`);
+    const textish = [part.alt, part.transcript, part.description, part.title, part.resource?.uri]
+        .filter((value) => typeof value === 'string' && value.trim())
+        .join('\u001f');
+    if (textish) fields.push(`meta=${hashSignatureParts([textish]).slice(0, 12)}`);
+    return fields.join(';');
+}
+
+export function buildSendInputSignature(input: InputEnvelope): string {
+    const text = typeof input.textFallback === 'string' ? input.textFallback.trim() : '';
+    const partSummaries = (input.parts || []).map(summarizeSendInputPart);
+    return hashSignatureParts([text, ...partSummaries]);
+}
+
+export function parseMaybeJson(value: any): any {
+    if (typeof value !== 'string') return value;
+    try {
+        return JSON.parse(value);
+    } catch {
+        return value;
+    }
+}
+
+export function getChatMessageSignature(message: ChatMessage | null | undefined): string {
+    return buildChatMessageSignature(message);
+}