pplx-zero 2.2.0 → 2.2.2

package/README.md

@@ -86,7 +86,6 @@ pplx --history
 |-------|-----|
 | `sonar` | Quick answers |
 | `sonar-pro` | Complex questions |
-| `sonar-reasoning` | Step-by-step |
 | `sonar-reasoning-pro` | Advanced reasoning |
 | `sonar-deep-research` | Research reports |
 

package/bin/pplx.js

@@ -1,7 +1,10 @@
 #!/usr/bin/env node
 
-const { spawn, execSync } = require('child_process');
-const { join } = require('path');
+import { spawn, execSync } from 'child_process';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
 
 const hasBun = () => {
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pplx-zero",
-  "version": "2.2.0",
+  "version": "2.2.2",
   "description": "Minimal Perplexity AI CLI - search from terminal",
   "author": "kenzo",
   "license": "MIT",
@@ -25,7 +25,8 @@
   },
   "files": [
     "src",
-    "bin"
+    "bin",
+    "!src/**/*.test.ts"
   ],
   "repository": {
     "type": "git",

package/src/api.ts

@@ -3,7 +3,7 @@ import type { FileAttachment } from './files';
 
 const API_URL = 'https://api.perplexity.ai/chat/completions';
 
-export const MODELS = ['sonar', 'sonar-pro', 'sonar-reasoning', 'sonar-reasoning-pro', 'sonar-deep-research'] as const;
+export const MODELS = ['sonar', 'sonar-pro', 'sonar-reasoning-pro', 'sonar-deep-research'] as const;
 export type Model = (typeof MODELS)[number];
 
 export interface SearchResult {
@@ -19,9 +19,10 @@ export interface StreamCallbacks {
 }
 
 interface MessageContent {
-  type: 'text' | 'file_url';
+  type: 'text' | 'file_url' | 'image_url';
   text?: string;
   file_url?: { url: string };
+  image_url?: { url: string };
   file_name?: string;
 }
 
@@ -32,12 +33,22 @@ function buildMessages(query: string, file?: FileAttachment): { role: string; co
 
   const content: MessageContent[] = [
     { type: 'text', text: query },
-    {
+  ];
+
+  if (file.type === 'image') {
+    // Images: use image_url with data URL prefix per Perplexity API spec
+    content.push({
+      type: 'image_url',
+      image_url: { url: `data:${file.mimeType};base64,${file.data}` },
+    });
+  } else {
+    // Documents: use file_url with raw base64
+    content.push({
       type: 'file_url',
       file_url: { url: file.data },
       file_name: file.filename,
-    },
-  ];
+    });
+  }
 
   return [{ role: 'user', content }];
 }

package/src/files.ts

@@ -1,5 +1,7 @@
-import { readFile } from 'node:fs/promises';
-import { extname } from 'node:path';
+import { readFile, stat } from 'node:fs/promises';
+import { extname, basename, resolve } from 'node:path';
+
+const MAX_FILE_SIZE = 50 * 1024 * 1024; // 50MB - Perplexity API limit
 
 const MIME_TYPES: Record<string, string> = {
   '.pdf': 'application/pdf',
@@ -20,14 +22,26 @@ export interface FileAttachment {
 }
 
 export async function encodeFile(path: string): Promise<FileAttachment> {
-  const ext = extname(path).toLowerCase();
+  // Security: prevent path traversal
+  if (path.includes('..')) {
+    throw new Error('Path traversal not allowed');
+  }
+  
+  const resolved = resolve(path);
+  const ext = extname(resolved).toLowerCase();
   const mimeType = MIME_TYPES[ext];
   
   if (!mimeType) {
     throw new Error(`Unsupported file type: ${ext}`);
   }
 
-  const buffer = await readFile(path);
+  // Security: check file size before reading into memory
+  const stats = await stat(resolved);
+  if (stats.size > MAX_FILE_SIZE) {
+    throw new Error(`File too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB (max 50MB)`);
+  }
+
+  const buffer = await readFile(resolved);
   const data = buffer.toString('base64');
   const isImage = mimeType.startsWith('image/');
 
@@ -35,7 +49,7 @@ export async function encodeFile(path: string): Promise<FileAttachment> {
     type: isImage ? 'image' : 'file',
     data,
     mimeType,
-    filename: path.split('/').pop() || 'file',
+    filename: basename(resolved),
   };
 }
 

package/src/index.ts

@@ -72,8 +72,14 @@ if (positionals.length === 0 && !values.continue) {
   process.exit(2);
 }
 
+// Validate model before proceeding
+if (!MODELS.includes(values.model as Model)) {
+  console.error(fmt.error(`Invalid model: ${values.model}. Available: ${MODELS.join(', ')}`));
+  process.exit(2);
+}
+const model = values.model as Model;
+
 let query = positionals.join(' ');
-const model = (MODELS.includes(values.model as Model) ? values.model : 'sonar') as Model;
 
 if (values.continue) {
   const last = await getLastEntry();
@@ -90,7 +96,25 @@ if (values.continue) {
 }
 
 const filePath = values.file || values.image;
-const file = filePath ? await encodeFile(filePath) : undefined;
+let file;
+if (filePath) {
+  try {
+    file = await encodeFile(filePath);
+  } catch (err) {
+    let msg = err instanceof Error ? err.message : 'Unknown error reading file';
+    if (msg.includes('ENOENT')) {
+      msg = `File not found: ${filePath}`;
+    }
+    console.error(fmt.error(msg));
+    process.exit(2);
+  }
+}
+
+// Validate model supports image input
+if (file?.type === 'image' && model === 'sonar-deep-research') {
+  console.error(fmt.error('sonar-deep-research does not support image input. Use sonar or sonar-pro.'));
+  process.exit(2);
+}
 
 const startTime = Date.now();
 let fullContent = '';

package/src/api.test.ts

@@ -1,21 +0,0 @@
-import { test, expect, describe } from 'bun:test';
-import { MODELS, type Model } from './api';
-
-describe('MODELS', () => {
-  test('includes all expected models', () => {
-    expect(MODELS).toContain('sonar');
-    expect(MODELS).toContain('sonar-pro');
-    expect(MODELS).toContain('sonar-reasoning');
-    expect(MODELS).toContain('sonar-reasoning-pro');
-    expect(MODELS).toContain('sonar-deep-research');
-  });
-
-  test('has exactly 5 models', () => {
-    expect(MODELS).toHaveLength(5);
-  });
-
-  test('Model type matches MODELS array', () => {
-    const model: Model = MODELS[0]!;
-    expect(MODELS.includes(model)).toBe(true);
-  });
-});

package/src/files.test.ts

@@ -1,71 +0,0 @@
-import { test, expect, describe } from 'bun:test';
-import { encodeFile, toDataUrl, type FileAttachment } from './files';
-import { writeFile, unlink } from 'node:fs/promises';
-import { join } from 'node:path';
-
-const TMP_DIR = '/tmp';
-
-describe('encodeFile', () => {
-  test('encodes text file correctly', async () => {
-    const testPath = join(TMP_DIR, 'test.txt');
-    await writeFile(testPath, 'hello world');
-    
-    const result = await encodeFile(testPath);
-    
-    expect(result.type).toBe('file');
-    expect(result.mimeType).toBe('text/plain');
-    expect(result.filename).toBe('test.txt');
-    expect(result.data).toBe(Buffer.from('hello world').toString('base64'));
-    
-    await unlink(testPath);
-  });
-
-  test('encodes PDF as file type', async () => {
-    const testPath = join(TMP_DIR, 'test.pdf');
-    await writeFile(testPath, '%PDF-1.4 test');
-    
-    const result = await encodeFile(testPath);
-    
-    expect(result.type).toBe('file');
-    expect(result.mimeType).toBe('application/pdf');
-    
-    await unlink(testPath);
-  });
-
-  test('encodes PNG as image type', async () => {
-    const testPath = join(TMP_DIR, 'test.png');
-    const pngHeader = Buffer.from([0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A]);
-    await writeFile(testPath, pngHeader);
-    
-    const result = await encodeFile(testPath);
-    
-    expect(result.type).toBe('image');
-    expect(result.mimeType).toBe('image/png');
-    
-    await unlink(testPath);
-  });
-
-  test('throws on unsupported file type', async () => {
-    const testPath = join(TMP_DIR, 'test.xyz');
-    await writeFile(testPath, 'test');
-    
-    await expect(encodeFile(testPath)).rejects.toThrow('Unsupported file type: .xyz');
-    
-    await unlink(testPath);
-  });
-});
-
-describe('toDataUrl', () => {
-  test('creates valid data URL', () => {
-    const attachment: FileAttachment = {
-      type: 'image',
-      data: 'aGVsbG8gd29ybGQ=',
-      mimeType: 'image/png',
-      filename: 'test.png',
-    };
-    
-    const result = toDataUrl(attachment);
-    
-    expect(result).toBe('data:image/png;base64,aGVsbG8gd29ybGQ=');
-  });
-});

package/src/history.test.ts

@@ -1,84 +0,0 @@
-import { test, expect, beforeEach, afterAll } from 'bun:test';
-import { appendHistory, readHistory, getLastEntry, clearHistory } from './history';
-
-beforeEach(async () => {
-  await clearHistory();
-});
-
-afterAll(async () => {
-  await clearHistory();
-});
-
-test('appendHistory creates entry', async () => {
-  await appendHistory({ q: 'test query', m: 'sonar', a: 'test answer' });
-  const entries = await readHistory();
-  expect(entries.length).toBe(1);
-  expect(entries[0]!.q).toBe('test query');
-  expect(entries[0]!.m).toBe('sonar');
-  expect(entries[0]!.a).toBe('test answer');
-  expect(entries[0]!.ts).toBeGreaterThan(0);
-});
-
-test('readHistory returns entries in reverse order', async () => {
-  await appendHistory({ q: 'first', m: 'sonar', a: 'a1' });
-  await appendHistory({ q: 'second', m: 'sonar-pro', a: 'a2' });
-  await appendHistory({ q: 'third', m: 'sonar', a: 'a3' });
-  
-  const entries = await readHistory();
-  expect(entries.length).toBe(3);
-  expect(entries[0]!.q).toBe('third');
-  expect(entries[1]!.q).toBe('second');
-  expect(entries[2]!.q).toBe('first');
-});
-
-test('readHistory respects limit', async () => {
-  await appendHistory({ q: 'one', m: 'sonar', a: 'a' });
-  await appendHistory({ q: 'two', m: 'sonar', a: 'a' });
-  await appendHistory({ q: 'three', m: 'sonar', a: 'a' });
-  
-  const entries = await readHistory(2);
-  expect(entries.length).toBe(2);
-  expect(entries[0]!.q).toBe('three');
-  expect(entries[1]!.q).toBe('two');
-});
-
-test('getLastEntry returns most recent', async () => {
-  await appendHistory({ q: 'old', m: 'sonar', a: 'old answer' });
-  await appendHistory({ q: 'new', m: 'sonar-pro', a: 'new answer' });
-  
-  const last = await getLastEntry();
-  expect(last?.q).toBe('new');
-  expect(last?.m).toBe('sonar-pro');
-});
-
-test('getLastEntry returns null when empty', async () => {
-  const last = await getLastEntry();
-  expect(last).toBeNull();
-});
-
-test('clearHistory removes all entries', async () => {
-  await appendHistory({ q: 'test', m: 'sonar', a: 'answer' });
-  await clearHistory();
-  const entries = await readHistory();
-  expect(entries.length).toBe(0);
-});
-
-test('appendHistory stores citations', async () => {
-  await appendHistory({ 
-    q: 'query', 
-    m: 'sonar', 
-    a: 'answer',
-    citations: ['https://example.com', 'https://test.com']
-  });
-  
-  const entries = await readHistory();
-  expect(entries[0]!.citations).toEqual(['https://example.com', 'https://test.com']);
-});
-
-test('appendHistory truncates long answers', async () => {
-  const longAnswer = 'x'.repeat(3000);
-  await appendHistory({ q: 'query', m: 'sonar', a: longAnswer });
-  
-  const entries = await readHistory();
-  expect(entries[0]!.a.length).toBe(2000);
-});

package/src/output.test.ts

@@ -1,41 +0,0 @@
-import { test, expect, describe } from 'bun:test';
-import { fmt } from './output';
-
-describe('fmt', () => {
-  test('model formats with cyan color', () => {
-    const result = fmt.model('sonar');
-    expect(result).toContain('[sonar]');
-    expect(result).toContain('\x1b[36m');
-    expect(result).toContain('\x1b[0m');
-  });
-
-  test('searching shows dim text', () => {
-    const result = fmt.searching();
-    expect(result).toContain('Searching...');
-    expect(result).toContain('\x1b[2m');
-  });
-
-  test('error formats with red color', () => {
-    const result = fmt.error('test error');
-    expect(result).toContain('Error: test error');
-    expect(result).toContain('\x1b[31m');
-  });
-
-  test('citation formats with number and URL', () => {
-    const result = fmt.citation(1, 'https://example.com');
-    expect(result).toContain('1.');
-    expect(result).toContain('https://example.com');
-  });
-
-  test('stats formats tokens and time', () => {
-    const result = fmt.stats(100, 1500);
-    expect(result).toContain('100 tokens');
-    expect(result).toContain('1.5s');
-  });
-
-  test('sources shows yellow header', () => {
-    const result = fmt.sources();
-    expect(result).toContain('Sources:');
-    expect(result).toContain('\x1b[33m');
-  });
-});