feat(attachments): support remote CLI file delivery

apps/mobile/src/components/agents/message-bubble.test.ts

@@ -49,8 +49,8 @@ vi.mock('./part-renderer', () => ({
   PartRenderer: () => null,
 }));
 vi.mock('./part-types', () => ({
-  isFilePart: () => false,
-  isTextPart: () => false,
+  isFilePart: vi.fn(() => false),
+  isTextPart: vi.fn(() => false),
 }));
 vi.mock('./use-message-copy', () => ({
   useMessageCopy: () => ({ copyMessage: vi.fn() }),
@@ -97,6 +97,36 @@ describe('MessageBubble regressions', () => {
   });
 });
 
+describe('MessageBubble user text join', () => {
+  it(
+    String.raw`joins text parts with \n\n so synthesized attachment notices get a blank line`,
+    async () => {
+      const { isTextPart } = await import('./part-types');
+      vi.mocked(isTextPart).mockReturnValue(true);
+
+      const { ChatMarkdownText: MockChatMarkdownText } = await import('./chat-markdown-text');
+
+      const message = userMessage('m8');
+      message.parts = [
+        { id: 'm8-prompt', sessionID: 'ses_1', messageID: 'm8', type: 'text', text: 'prompt' },
+        {
+          id: 'm8-attachment',
+          sessionID: 'ses_1',
+          messageID: 'm8',
+          type: 'text',
+          text: 'attachment saved: file.pdf',
+        },
+      ] as typeof message.parts;
+
+      const tree = await renderBubble(message);
+
+      const element = findElementByTypeFn(tree, MockChatMarkdownText);
+      expect(element).not.toBeNull();
+      expect(element?.props.value as string).toContain('\n\n');
+    }
+  );
+});
+
 describe('MessageBubble in-bubble text selection context', () => {
   it('wraps the assistant parts view in InMessageBubbleContext.Provider with value true', async () => {
     const { InMessageBubbleContext } = await import('./bubble-text-selection-context');
@@ -117,6 +147,31 @@ describe('MessageBubble in-bubble text selection context', () => {
   });
 });
 
+function findElementByTypeFn(
+  node: unknown,
+  typeFn: unknown
+): { type: unknown; props: Record<string, unknown> } | null {
+  if (node == null || typeof node !== 'object') {
+    return null;
+  }
+  const element = node as { type?: unknown; props?: Record<string, unknown> };
+  if (element.type === typeFn) {
+    return element as { type: unknown; props: Record<string, unknown> };
+  }
+  const children = element.props?.children;
+  if (Array.isArray(children)) {
+    for (const child of children) {
+      const hit = findElementByTypeFn(child, typeFn);
+      if (hit) {
+        return hit;
+      }
+    }
+  } else if (children && typeof children === 'object') {
+    return findElementByTypeFn(children, typeFn);
+  }
+  return null;
+}
+
 function findProvider(
   node: unknown,
   providerType: unknown

apps/mobile/src/components/agents/message-bubble.tsx

@@ -73,10 +73,13 @@ export function MessageBubble({
   }
 
   if (isUser) {
+    // Composer, queued-message synthesis, and slash commands emit exactly one
+    // human-authored text part, so the separator separates it from synthesized
+    // attachment notices.
     const textContent = message.parts
       .filter(isTextPart)
       .map(p => p.text)
-      .join('');
+      .join('\n\n');
     const fileParts = message.parts.filter(isFilePart);
     const showQueuedBadge = deliveryState?.status === 'queued';
     const a11y = buildAgentMessageBubbleAccessibilityProps({ isUser: true, canCopy: true });

apps/mobile/src/components/agents/mobile-session-manager.test.ts

@@ -36,6 +36,7 @@ vi.mock('@/lib/user-web-connection-lifecycle', () => ({
   createNativeUserWebConnectionLifecycleHooks: vi.fn(() => ({})),
 }));
 vi.mock('@/components/agents/tool-card-image-cache', () => ({
+  cacheToolAttachment: vi.fn(),
   cacheToolCardImage: vi.fn(),
 }));
 

apps/mobile/src/components/agents/mobile-session-manager.ts

@@ -23,7 +23,7 @@ import { SPAWNED_NOT_FOUND_MAX_ATTEMPTS } from '@/lib/spawned-not-found-retry';
 import { trpcClient } from '@/lib/trpc';
 import { AUTH_TOKEN_KEY } from '@/lib/storage-keys';
 import { createNativeUserWebConnectionLifecycleHooks } from '@/lib/user-web-connection-lifecycle';
-import { cacheToolCardImage } from '@/components/agents/tool-card-image-cache';
+import { cacheToolAttachment } from '@/components/agents/tool-card-image-cache';
 import { type inferRouterOutputs, type MobileRouter } from '@kilocode/trpc/mobile';
 
 type SessionWithRuntimeState =
@@ -143,7 +143,9 @@ export function createMobileAgentSessionManager({
     websocketHeaders: { Origin: WEB_BASE_URL },
     lifecycleHooks: createNativeUserWebConnectionLifecycleHooks(),
     userWebConnection,
-    onImageAttachment: cacheToolCardImage,
+    onToolAttachment: (partId, attachment) => {
+      cacheToolAttachment(partId, attachment);
+    },
     resolveSession: async (kiloSessionId: KiloSessionId): Promise<ResolvedSession> => {
       // Read-only is only ever returned once we have successful evidence the
       // session isn't cloud-agent or remote. A failed query here must

apps/mobile/src/components/agents/tool-card-attachments.test.ts

@@ -2,6 +2,7 @@ import { type FilePart, type ToolPart } from '@kilocode/cloud-agent-sdk';
 import { describe, expect, it } from 'vitest';
 
 import {
+  getToolFileAttachments,
   getToolImageAttachments,
   IMAGE_PREVIEW_FALLBACK_ASPECT_RATIO,
   IMAGE_PREVIEW_MAX_ASPECT_RATIO,
@@ -20,14 +21,18 @@ function makeAttachment(mime: string, url: string): FilePart {
   };
 }
 
-function makeToolPart(status: ToolPart['state']['status'], attachments?: FilePart[]): ToolPart {
+function makeToolPart(
+  status: ToolPart['state']['status'],
+  attachments?: FilePart[],
+  tool = 'read'
+): ToolPart {
   const base = {
     id: 'part-1',
     sessionID: 'session-1',
     messageID: 'message-1',
     type: 'tool' as const,
     callID: 'call-1',
-    tool: 'read',
+    tool,
   };
 
   if (status === 'pending') {
@@ -98,6 +103,51 @@ describe('getToolImageAttachments', () => {
   });
 });
 
+describe('getToolFileAttachments', () => {
+  it('returns empty for non-send_file tools even when completed', () => {
+    const pdf = makeAttachment('application/pdf', '');
+    expect(getToolFileAttachments(makeToolPart('completed', [pdf], 'read'))).toEqual([]);
+  });
+
+  it('returns empty when attachments key is absent', () => {
+    expect(getToolFileAttachments(makeToolPart('completed', undefined, 'send_file'))).toEqual([]);
+  });
+
+  it('returns empty for pending, running, and error states', () => {
+    const pdf = makeAttachment('application/pdf', '');
+    expect(getToolFileAttachments(makeToolPart('pending', [pdf], 'send_file'))).toEqual([]);
+    expect(getToolFileAttachments(makeToolPart('running', [pdf], 'send_file'))).toEqual([]);
+    expect(getToolFileAttachments(makeToolPart('error', [pdf], 'send_file'))).toEqual([]);
+  });
+
+  it('keeps non-image attachments from send_file', () => {
+    const pdf = makeAttachment('application/pdf', '');
+    const txt = makeAttachment('text/plain', '');
+    const result = getToolFileAttachments(makeToolPart('completed', [pdf, txt], 'send_file'));
+    expect(result).toEqual([pdf, txt]);
+  });
+
+  it('drops image attachments (they belong to image rendering)', () => {
+    const png = makeAttachment('image/png', '');
+    const pdf = makeAttachment('application/pdf', '');
+    const result = getToolFileAttachments(makeToolPart('completed', [png, pdf], 'send_file'));
+    expect(result).toEqual([pdf]);
+  });
+
+  it('keeps blank-url non-image attachments', () => {
+    const pdf = makeAttachment('application/pdf', '');
+    expect(getToolFileAttachments(makeToolPart('completed', [pdf], 'send_file'))).toEqual([pdf]);
+  });
+
+  it('filters a mixed array preserving order', () => {
+    const pdf = makeAttachment('application/pdf', '');
+    const png = makeAttachment('image/png', '');
+    const txt = makeAttachment('text/plain', '');
+    const result = getToolFileAttachments(makeToolPart('completed', [pdf, png, txt], 'send_file'));
+    expect(result).toEqual([pdf, txt]);
+  });
+});
+
 describe('resolveImagePreviewAspectRatio', () => {
   it('passes through a normal landscape ratio', () => {
     expect(resolveImagePreviewAspectRatio(1600, 900)).toBeCloseTo(1600 / 900);

apps/mobile/src/components/agents/tool-card-attachments.ts

@@ -20,6 +20,20 @@ export function getToolImageAttachments(part: ToolPart): FilePart[] {
   return (part.state.attachments ?? []).filter(item => item.mime.startsWith('image/'));
 }
 
+/**
+ * Non-image file attachments on a completed `send_file` tool part.
+ *
+ * Only returns attachments from `send_file` tool parts — matching the
+ * processor gate. Blank-`url` entries are kept; renderability is decided
+ * by the file-system cache lookup.
+ */
+export function getToolFileAttachments(part: ToolPart): FilePart[] {
+  if (part.tool !== 'send_file' || part.state.status !== 'completed') {
+    return [];
+  }
+  return (part.state.attachments ?? []).filter(item => !item.mime.startsWith('image/'));
+}
+
 /**
  * Clamp an image's intrinsic ratio so a tall screenshot still gets a usable
  * preview height in a tool card. `contentFit="contain"` letterboxes the rest.

apps/mobile/src/components/agents/tool-card-file-attachments.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from 'vitest';
+
+/**
+ * Replicates the file-attachment label logic from ToolCardFileAttachments:
+ *   const label = attachment.filename || 'File';
+ *
+ * Also asserts the mimeType forwarding contract: the chip passes
+ * { mimeType: attachment.mime } to shareLocalFile(uri, { mimeType }).
+ *
+ * The actual rendering (unavailable row vs chip) and press handler are
+ * exercised through share-remote-file.test.ts (mimeType passthrough), the
+ * image-cache.test.ts (cache miss → no URI → unavailable row trigger), and
+ * manual E2E.
+ */
+function resolveFileAttachmentLabel(filename: string | undefined): string {
+  return filename ?? 'File';
+}
+
+function buildShareMimeOptions(mime: string): { mimeType: string } {
+  return { mimeType: mime };
+}
+
+describe('ToolCardFileAttachments (label + mimeType contract)', () => {
+  it('uses the attachment filename as the chip label', () => {
+    expect(resolveFileAttachmentLabel('report.pdf')).toBe('report.pdf');
+  });
+
+  it('falls back to "File" when filename is absent', () => {
+    expect(resolveFileAttachmentLabel(undefined)).toBe('File');
+    // Empty string is a value, not absence — preserved as-is with ??.
+    expect(resolveFileAttachmentLabel('')).toBe('');
+  });
+
+  it('passes mimeType to the share options', () => {
+    expect(buildShareMimeOptions('application/pdf')).toEqual({
+      mimeType: 'application/pdf',
+    });
+    expect(buildShareMimeOptions('text/plain')).toEqual({
+      mimeType: 'text/plain',
+    });
+  });
+});

apps/mobile/src/components/agents/tool-card-file-attachments.tsx

@@ -0,0 +1,97 @@
+import { type ToolPart } from '@kilocode/cloud-agent-sdk';
+import { FileIcon, Share2 } from 'lucide-react-native';
+import { Pressable, View } from 'react-native';
+import { toast } from 'sonner-native';
+
+import { Text } from '@/components/ui/text';
+import { useThemeColors } from '@/lib/hooks/use-theme-colors';
+import {
+  getShareRemoteFileReason,
+  shareLocalFile,
+  ShareRemoteFileError,
+} from '@/lib/share-remote-file';
+
+import { getToolFileAttachments } from './tool-card-attachments';
+import { useToolCardImageUri } from './tool-card-image-cache';
+
+function FileChip({
+  label,
+  mime,
+  partId,
+}: Readonly<{
+  label: string;
+  mime: string;
+  partId: string;
+}>) {
+  const colors = useThemeColors();
+  const uri = useToolCardImageUri(partId);
+  const available = uri !== undefined;
+
+  if (!available) {
+    return (
+      <View className="flex-row items-center gap-2 rounded-md bg-neutral-100 px-3 py-2 dark:bg-neutral-900">
+        <FileIcon size={14} color={colors.mutedForeground} />
+        <Text className="text-xs text-muted-foreground">File unavailable in this session.</Text>
+      </View>
+    );
+  }
+
+  const fileUri = uri;
+
+  async function handleShare() {
+    try {
+      await shareLocalFile(fileUri, { mimeType: mime });
+    } catch (error: unknown) {
+      const reason = getShareRemoteFileReason(error);
+      if (reason === 'sharing-unavailable') {
+        toast.error('File sharing is not available on this device.');
+        return;
+      }
+      if (error instanceof ShareRemoteFileError) {
+        toast.error('Failed to share file. Please try again.');
+        return;
+      }
+      toast.error('Share failed');
+    }
+  }
+
+  return (
+    <View className="flex-row items-center gap-2 rounded-md bg-neutral-100 px-3 py-2 dark:bg-neutral-900">
+      <FileIcon size={16} color={colors.mutedForeground} />
+      <View className="flex-1">
+        <Text className="text-xs font-medium text-foreground" numberOfLines={1}>
+          {label}
+        </Text>
+        <Text className="text-xs text-muted-foreground">{mime}</Text>
+      </View>
+      <Pressable
+        className="rounded p-1 active:opacity-60"
+        onPress={() => {
+          void handleShare();
+        }}
+        accessibilityRole="button"
+        accessibilityLabel={`Share ${label}`}
+      >
+        <Share2 size={16} color={colors.mutedForeground} />
+      </Pressable>
+    </View>
+  );
+}
+
+export function ToolCardFileAttachments({ part }: Readonly<{ part: ToolPart }>) {
+  const attachments = getToolFileAttachments(part);
+  if (attachments.length === 0) {
+    return null;
+  }
+
+  return (
+    <View className="gap-2">
+      {attachments.map(attachment => {
+        const label = attachment.filename ?? 'File';
+        return (
+          <FileChip key={attachment.id} label={label} mime={attachment.mime} partId={part.id} />
+        );
+      })}
+    </View>
+  );
+}