@lzdi/pty-remote-cli 0.1.3

package/src/cli/pty.ts

@@ -0,0 +1,162 @@
+import { randomUUID } from 'node:crypto';
+
+import { spawn as spawnPty, type IPty } from 'node-pty';
+
+export interface ClaudePtySession {
+  pty: IPty;
+  recentOutput: string;
+}
+
+export type ClaudePtyLifecycle = 'not_ready' | 'idle' | 'running';
+
+interface StartClaudePtySessionOptions {
+  claudeBin: string;
+  cols: number;
+  cwd: string;
+  env: NodeJS.ProcessEnv;
+  permissionMode: string;
+  resumeSessionId?: string | null;
+  rows: number;
+  onData: (chunk: string) => void;
+  onExit: () => void;
+}
+
+export function createClaudeLaunchConfig(
+  claudeBin: string,
+  permissionMode: string,
+  resumeSessionId?: string | null
+): {
+  command: string;
+  args: string[];
+  sessionId: string;
+} {
+  if (resumeSessionId) {
+    return {
+      command: claudeBin,
+      args: ['--permission-mode', permissionMode, '--resume', resumeSessionId],
+      sessionId: resumeSessionId
+    };
+  }
+
+  const sessionId = randomUUID();
+  return {
+    command: claudeBin,
+    args: ['--permission-mode', permissionMode, '--session-id', sessionId],
+    sessionId
+  };
+}
+
+export function startClaudePtySession(options: StartClaudePtySessionOptions): {
+  session: ClaudePtySession;
+  sessionId: string;
+} {
+  const launch = createClaudeLaunchConfig(options.claudeBin, options.permissionMode, options.resumeSessionId);
+  const pty = spawnPty(launch.command, launch.args, {
+    cols: options.cols,
+    rows: options.rows,
+    cwd: options.cwd,
+    env: options.env,
+    name: 'xterm-256color'
+  });
+
+  const session: ClaudePtySession = {
+    pty,
+    recentOutput: ''
+  };
+
+  pty.onData((chunk) => {
+    options.onData(chunk);
+  });
+
+  pty.onExit(() => {
+    options.onExit();
+  });
+
+  return {
+    session,
+    sessionId: launch.sessionId
+  };
+}
+
+export function stopClaudePtySession(session: ClaudePtySession | null): void {
+  if (!session) {
+    return;
+  }
+
+  try {
+    session.pty.kill();
+  } catch {
+    // ignore
+  }
+}
+
+export function resizeClaudePtySession(session: ClaudePtySession | null, cols: number, rows: number): void {
+  if (!session) {
+    return;
+  }
+
+  try {
+    session.pty.resize(cols, rows);
+  } catch {
+    // ignore resize failures during session transitions
+  }
+}
+
+export function appendRecentOutput(session: ClaudePtySession, chunk: string, maxChars: number): string {
+  session.recentOutput = `${session.recentOutput}${chunk}`.slice(-maxChars);
+  return session.recentOutput;
+}
+
+function tailOutput(text: string, maxChars = 8_000): string {
+  return normalizeOutput(text).slice(-maxChars);
+}
+
+function normalizeOutput(text: string): string {
+  return text
+    .replace(/\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])/g, '')
+    .replace(/\r/g, '\n');
+}
+
+const RUNNING_LINE_PATTERN = /(^|\n)\s*[*·✶✻]\s+[^\n]*?\b[\p{L}-]*ing(?:\.{3}|…)?\s*$/gimu;
+const PROMPT_LINE_PATTERN = /(^|\n)\s*>\s*[^\n]*$/gm;
+const PROMPT_HINT_PATTERN = /Try\s+"|--\s*INSERT\s*--|Thinking on|shift\+tab to cycle|\/ide\b/gi;
+
+function findLastMatchIndex(pattern: RegExp, text: string): number {
+  let lastIndex = -1;
+
+  for (const match of text.matchAll(pattern)) {
+    lastIndex = match.index ?? lastIndex;
+  }
+
+  return lastIndex;
+}
+
+export function getClaudePtyLifecycle(output: string): ClaudePtyLifecycle {
+  const tail = tailOutput(output);
+  const lastRunningIndex = findLastMatchIndex(RUNNING_LINE_PATTERN, tail);
+  const lastPromptIndex = findLastMatchIndex(PROMPT_LINE_PATTERN, tail);
+  const lastHintIndex = findLastMatchIndex(PROMPT_HINT_PATTERN, tail);
+
+  if (lastRunningIndex > Math.max(lastPromptIndex, lastHintIndex)) {
+    return 'running';
+  }
+
+  if (lastPromptIndex >= 0 && lastHintIndex >= 0 && Math.max(lastPromptIndex, lastHintIndex) > lastRunningIndex) {
+    return 'idle';
+  }
+
+  return 'not_ready';
+}
+
+export function looksReadyForInput(output: string): boolean {
+  return getClaudePtyLifecycle(output) === 'idle';
+}
+
+export function isInsertModeVisible(output: string): boolean {
+  return tailOutput(output).toLowerCase().includes('-- insert --');
+}
+
+export function looksLikeBypassPrompt(output: string): boolean {
+  const plainText = tailOutput(output).toLowerCase();
+  return plainText.includes('bypass permissions') && plainText.includes('yes, i accept');
+}

package/src/cli-main.ts

@@ -0,0 +1,18 @@
+import { startCliClient } from './cli/client.ts';
+import { runThreadsCli } from './threads-cli.ts';
+
+async function main(): Promise<void> {
+  const [command, ...restArgs] = process.argv.slice(2);
+
+  if (command === 'threads') {
+    process.exitCode = await runThreadsCli(restArgs);
+    return;
+  }
+
+  await startCliClient();
+}
+
+void main().catch((error) => {
+  console.error(error);
+  process.exit(1);
+});

package/src/project-history.ts

@@ -0,0 +1,175 @@
+import { promises as fs, type Dirent } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import type { ChatMessage } from '@lzdi/pty-remote-protocol/runtime-types.ts';
+import type { ProjectSessionSummary } from '@lzdi/pty-remote-protocol/protocol.ts';
+import { parseClaudeJsonlMessages, resolveClaudeProjectFilesPath } from './cli/jsonl.ts';
+
+const DEFAULT_MAX_SESSIONS = 12;
+const PENDING_INPUT_LABEL = '待输入';
+const CLAUDE_SESSION_FILE_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+
+interface SessionFileEntry {
+  filePath: string;
+  sessionId: string;
+  updatedAtMs: number;
+}
+
+function normalizePreview(text: string): string {
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+function getUserMessageText(message: ChatMessage | undefined): string {
+  if (!message) {
+    return '';
+  }
+
+  return normalizePreview(
+    message.blocks
+      .map((block) => {
+        if (block.type === 'text') {
+          return block.text;
+        }
+        return '';
+      })
+      .join(' ')
+  );
+}
+
+function getLatestUserTextMessage(messages: ChatMessage[]): ChatMessage | undefined {
+  return [...messages].reverse().find((message) => message.role === 'user' && Boolean(getUserMessageText(message)));
+}
+
+function getMessagePreview(message: ChatMessage | undefined): string {
+  if (!message) {
+    return '';
+  }
+
+  const text = message.blocks
+    .map((block) => {
+      if (block.type === 'text') {
+        return block.text;
+      }
+      if (block.type === 'tool_use') {
+        return `${block.toolName} ${block.input}`;
+      }
+      return block.content;
+    })
+    .join(' ');
+
+  return normalizePreview(text);
+}
+
+function compactTitle(text: string): string {
+  if (text.length <= 44) {
+    return text;
+  }
+
+  return `${text.slice(0, 41)}...`;
+}
+
+async function summarizeSessionFile(filePath: string, cwd: string): Promise<ProjectSessionSummary | null> {
+  const rawJsonl = await fs.readFile(filePath, 'utf8');
+  const messages = parseClaudeJsonlMessages(rawJsonl);
+  if (messages.length === 0) {
+    return null;
+  }
+  const lastUserMessage = getLatestUserTextMessage(messages);
+  const preview = getUserMessageText(lastUserMessage) || PENDING_INPUT_LABEL;
+  const stat = await fs.stat(filePath);
+  const updatedAt = lastUserMessage?.createdAt ?? new Date(stat.mtimeMs).toISOString();
+
+  return {
+    providerId: 'claude',
+    sessionId: path.basename(filePath, '.jsonl'),
+    cwd,
+    title: compactTitle(preview),
+    preview,
+    updatedAt,
+    messageCount: messages.length
+  };
+}
+
+async function listSessionFiles(projectFilesPath: string): Promise<SessionFileEntry[]> {
+  let entries: Dirent[];
+  try {
+    entries = await fs.readdir(projectFilesPath, { withFileTypes: true });
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+
+  const sessionFiles: SessionFileEntry[] = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !CLAUDE_SESSION_FILE_PATTERN.test(entry.name)) {
+      continue;
+    }
+
+    const filePath = path.join(projectFilesPath, entry.name);
+    let stat;
+    try {
+      stat = await fs.stat(filePath);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT') {
+        continue;
+      }
+      throw error;
+    }
+    if (!stat.isFile()) {
+      continue;
+    }
+    if (stat.size <= 0) {
+      continue;
+    }
+
+    sessionFiles.push({
+      filePath,
+      sessionId: path.basename(entry.name, '.jsonl'),
+      updatedAtMs: stat.mtimeMs
+    } satisfies SessionFileEntry);
+  }
+
+  return sessionFiles.sort(
+    (left, right) => right.updatedAtMs - left.updatedAtMs || right.sessionId.localeCompare(left.sessionId)
+  );
+}
+
+export async function listProjectSessions(projectRoot: string, maxSessions = DEFAULT_MAX_SESSIONS): Promise<ProjectSessionSummary[]> {
+  const resolvedProjectRoot = path.resolve(projectRoot);
+  const canonicalProjectRoot = await fs.realpath(resolvedProjectRoot).catch(() => resolvedProjectRoot);
+  const projectFilesPath = resolveClaudeProjectFilesPath(canonicalProjectRoot, os.homedir());
+  const normalizedMax = Number.isFinite(maxSessions) ? Math.max(1, Math.min(Math.floor(maxSessions), 50)) : DEFAULT_MAX_SESSIONS;
+  const sessionFiles = await listSessionFiles(projectFilesPath);
+  const sessions: ProjectSessionSummary[] = [];
+
+  for (const entry of sessionFiles) {
+    let summary: ProjectSessionSummary | null;
+    try {
+      summary = await summarizeSessionFile(entry.filePath, canonicalProjectRoot);
+    } catch (error) {
+      const code = (error as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT') {
+        continue;
+      }
+      throw error;
+    }
+    if (!summary) {
+      continue;
+    }
+
+    sessions.push(summary);
+    if (sessions.length >= normalizedMax) {
+      break;
+    }
+  }
+
+  return sessions.sort((left, right) => {
+    const timestampDiff = new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime();
+    return timestampDiff || right.sessionId.localeCompare(left.sessionId);
+  });
+}

package/src/providers/claude-history.ts

@@ -0,0 +1,124 @@
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import type { ProjectSessionSummary } from '@lzdi/pty-remote-protocol/protocol.ts';
+
+const DEFAULT_MAX_SESSIONS = 12;
+const PENDING_INPUT_LABEL = '待输入';
+
+interface ClaudeHistoryEntry {
+  display?: unknown;
+  timestamp?: unknown;
+  project?: unknown;
+  sessionId?: unknown;
+}
+
+export interface ClaudeHistoryOptions {
+  historyPath?: string;
+}
+
+function normalizeMaxSessions(maxSessions: number): number {
+  return Number.isFinite(maxSessions) ? Math.max(1, Math.min(Math.floor(maxSessions), 50)) : DEFAULT_MAX_SESSIONS;
+}
+
+function normalizePreview(text: string): string {
+  return text.replace(/\s+/g, ' ').trim();
+}
+
+function compactTitle(text: string): string {
+  if (text.length <= 44) {
+    return text;
+  }
+  return `${text.slice(0, 41)}...`;
+}
+
+function coerceTimestampMs(value: unknown): number | null {
+  if (typeof value === 'number' && Number.isFinite(value)) {
+    return value > 1e12 ? value : value * 1000;
+  }
+  if (typeof value === 'string') {
+    const asNumber = Number(value);
+    if (Number.isFinite(asNumber)) {
+      return asNumber > 1e12 ? asNumber : asNumber * 1000;
+    }
+    const asDate = Date.parse(value);
+    if (Number.isFinite(asDate)) {
+      return asDate;
+    }
+  }
+  return null;
+}
+
+export function resolveClaudeHistoryPath(options: ClaudeHistoryOptions = {}): string {
+  return options.historyPath ?? path.join(os.homedir(), '.claude', 'history.jsonl');
+}
+
+export async function listClaudeRecentSessions(
+  maxSessions = DEFAULT_MAX_SESSIONS,
+  options: ClaudeHistoryOptions = {}
+): Promise<ProjectSessionSummary[]> {
+  const normalizedMax = normalizeMaxSessions(maxSessions);
+  const historyPath = resolveClaudeHistoryPath(options);
+  const raw = await fs.readFile(historyPath, 'utf8').catch((error: NodeJS.ErrnoException) => {
+    if (error.code === 'ENOENT') {
+      return '';
+    }
+    throw error;
+  });
+  if (!raw.trim()) {
+    return [];
+  }
+
+  const summaries = new Map<string, ProjectSessionSummary>();
+  const lines = raw.split('\n');
+  for (let index = lines.length - 1; index >= 0; index -= 1) {
+    const line = lines[index]?.trim();
+    if (!line) {
+      continue;
+    }
+
+    let parsed: ClaudeHistoryEntry;
+    try {
+      parsed = JSON.parse(line) as ClaudeHistoryEntry;
+    } catch {
+      continue;
+    }
+
+    const sessionId = typeof parsed.sessionId === 'string' ? parsed.sessionId.trim() : '';
+    if (!sessionId || summaries.has(sessionId)) {
+      continue;
+    }
+
+    const cwd = typeof parsed.project === 'string' ? parsed.project.trim() : '';
+    if (!cwd) {
+      continue;
+    }
+
+    const tsMs = coerceTimestampMs(parsed.timestamp);
+    if (tsMs === null) {
+      continue;
+    }
+
+    const previewSource = typeof parsed.display === 'string' ? parsed.display : '';
+    const preview = normalizePreview(previewSource) || PENDING_INPUT_LABEL;
+    summaries.set(sessionId, {
+      providerId: 'claude',
+      sessionId,
+      cwd: path.resolve(cwd),
+      title: compactTitle(preview),
+      preview,
+      updatedAt: new Date(tsMs).toISOString(),
+      messageCount: 0
+    });
+
+    if (summaries.size >= normalizedMax) {
+      break;
+    }
+  }
+
+  return [...summaries.values()].sort((left, right) => {
+    const timestampDiff = new Date(right.updatedAt).getTime() - new Date(left.updatedAt).getTime();
+    return timestampDiff || right.sessionId.localeCompare(left.sessionId);
+  });
+}

package/src/providers/claude.ts

@@ -0,0 +1,66 @@
+import type { ProjectSessionSummary } from '@lzdi/pty-remote-protocol/protocol.ts';
+
+import { listClaudeRecentSessions } from './claude-history.ts';
+import { listProviderSlashCommands } from './slash-commands.ts';
+import { PtyManager, type PtyManagerOptions } from '../cli/pty-manager.ts';
+
+import type { ProviderRuntime, ProviderRuntimeCallbacks, ProviderRuntimeSelection } from './provider-runtime.ts';
+
+export function createClaudeProviderRuntime(
+  options: PtyManagerOptions,
+  callbacks: ProviderRuntimeCallbacks
+): ProviderRuntime {
+  const manager = new PtyManager(options, callbacks);
+
+  return {
+    providerId: 'claude',
+    activateConversation(selection: ProviderRuntimeSelection) {
+      return manager.activateConversation(selection);
+    },
+    cleanupConversation(target) {
+      return manager.cleanupConversation(target);
+    },
+    cleanupProject(cwd: string) {
+      return manager.cleanupProject(cwd);
+    },
+    dispatchMessage(content: string) {
+      return manager.dispatchMessage(content);
+    },
+    getOlderMessages(beforeMessageId?: string, maxMessages?: number) {
+      return manager.getOlderMessages(beforeMessageId, maxMessages);
+    },
+    getRegistrationPayload() {
+      return manager.getRegistrationPayload();
+    },
+    getSnapshot() {
+      return manager.getSnapshot();
+    },
+    listSlashCommands() {
+      return listProviderSlashCommands('claude');
+    },
+    listProjectConversations(_projectRoot: string, maxSessions?: number): Promise<ProjectSessionSummary[]> {
+      return listClaudeRecentSessions(maxSessions);
+    },
+    listManagedPtyHandles() {
+      return Promise.resolve(manager.listManagedPtyHandles());
+    },
+    primeActiveTerminalFrame() {
+      return manager.primeActiveTerminalFrame();
+    },
+    refreshActiveState() {
+      return manager.refreshActiveState();
+    },
+    resetActiveConversation() {
+      return manager.resetActiveThread();
+    },
+    shutdown() {
+      return manager.shutdown();
+    },
+    stopActiveRun() {
+      return manager.stopActiveRun();
+    },
+    updateTerminalSize(cols: number, rows: number) {
+      manager.updateTerminalSize(cols, rows);
+    }
+  };
+}