@lzdi/pty-remote-cli 0.1.3

package/bin/pty-remote-cli.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { spawn } from 'node:child_process';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, '..');
+const requireFromBin = createRequire(import.meta.url);
+const TSX_IMPORT_PATH = requireFromBin.resolve('tsx', { paths: [ROOT_DIR] });
+
+const child = spawn(
+  process.execPath,
+  ['--disable-warning=ExperimentalWarning', '--import', TSX_IMPORT_PATH, path.join(ROOT_DIR, 'src/cli-main.ts'), ...process.argv.slice(2)],
+  {
+    stdio: 'inherit',
+    env: process.env
+  }
+);
+
+child.on('exit', (code) => {
+  process.exit(typeof code === 'number' ? code : 0);
+});

package/cli.conf

@@ -0,0 +1,51 @@
+# CLI config for pty-remote
+# Lines are KEY=VALUE. Empty values are ignored. Environment variables override this file.
+
+# Socket
+HOST=127.0.0.1
+PORT=3001
+# SOCKET_URL=
+
+# Providers
+PTY_REMOTE_PROVIDERS=claude,codex
+
+# CLI identity
+# PTY_REMOTE_CLI_ID=
+
+# Limits
+PTY_REMOTE_MAX_DETACHED_PTYS=5
+
+# Terminal
+TERMINAL_COLS=120
+TERMINAL_ROWS=32
+TERMINAL_FRAME_SCROLLBACK=500
+RECENT_OUTPUT_MAX_CHARS=12000
+
+# Timeouts & debounce
+CLAUDE_READY_TIMEOUT_MS=20000
+CODEX_READY_TIMEOUT_MS=20000
+PROMPT_SUBMIT_DELAY_MS=120
+JSONL_REFRESH_DEBOUNCE_MS=120
+SNAPSHOT_EMIT_DEBOUNCE_MS=200
+
+# Snapshot limits
+SNAPSHOT_MESSAGES_MAX=40
+OLDER_MESSAGES_PAGE_MAX=40
+
+# GC / TTL
+GC_INTERVAL_MS=300000
+DETACHED_PTY_TTL_MS=43200000
+DETACHED_DRAFT_TTL_MS=300000
+DETACHED_JSONL_MISSING_TTL_MS=120000
+
+# Provider bins
+# CLAUDE_BIN=
+# CODEX_BIN=
+
+# Claude permission mode
+CLAUDE_PERMISSION_MODE=bypassPermissions
+
+# Codex history
+# CODEX_HOME=
+# CODEX_HISTORY_PATH=
+# CODEX_SESSIONS_ROOT_PATH=

package/codex_template.jsonl

@@ -0,0 +1 @@
+{"timestamp":"{{timestamp}}","type":"session_meta","payload":{"id":"{{session_id}}","timestamp":"{{timestamp}}","cwd":"{{cwd}}","originator":"codex_cli_rs","cli_version":"{{cli_version}}","source":"cli"}}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@lzdi/pty-remote-cli",
+  "version": "0.1.3",
+  "private": false,
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/234687552/pty-remote"
+  },
+  "engines": {
+    "node": ">=23.0.0"
+  },
+  "scripts": {
+    "build": "node scripts/ensure-node-pty-helper.js",
+    "dev": "tsx watch src/cli-main.ts",
+    "dev:claude": "PTY_REMOTE_PROVIDER=claude tsx watch src/cli-main.ts",
+    "dev:codex": "PTY_REMOTE_PROVIDER=codex tsx watch src/cli-main.ts",
+    "postinstall": "node scripts/ensure-node-pty-helper.js",
+    "start": "node bin/pty-remote-cli.js",
+    "start:claude": "PTY_REMOTE_PROVIDER=claude node bin/pty-remote-cli.js",
+    "start:codex": "PTY_REMOTE_PROVIDER=codex node bin/pty-remote-cli.js",
+    "threads": "node bin/pty-remote-cli.js threads"
+  },
+  "dependencies": {
+    "@lzdi/pty-remote-protocol": "0.1.3",
+    "@xterm/headless": "^6.0.0",
+    "node-pty": "^1.1.0",
+    "socket.io-client": "^4.8.3",
+    "tsx": "^4.20.6"
+  },
+  "devDependencies": {
+    "@types/node": "^24.5.2",
+    "typescript": "^5.9.3"
+  },
+  "bin": {
+    "pty-remote-cli": "bin/pty-remote-cli.js"
+  },
+  "files": [
+    "bin",
+    "cli.conf",
+    "codex_template.jsonl",
+    "scripts",
+    "src"
+  ]
+}

package/scripts/ensure-node-pty-helper.js

@@ -0,0 +1,24 @@
+import { chmodSync, existsSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+if (process.platform !== 'darwin' || process.arch !== 'arm64') {
+  process.exit(0);
+}
+
+const helperCandidates = [
+  path.join(process.cwd(), 'node_modules', 'node-pty', 'prebuilds', 'darwin-arm64', 'spawn-helper'),
+  path.join(process.cwd(), 'node_modules', 'node-pty', 'build', 'Release', 'spawn-helper')
+];
+
+for (const helperPath of helperCandidates) {
+  if (!existsSync(helperPath)) {
+    continue;
+  }
+
+  const mode = statSync(helperPath).mode & 0o111;
+  if (mode === 0o111) {
+    continue;
+  }
+
+  chmodSync(helperPath, 0o755);
+}

package/src/attachments/manager.ts

@@ -0,0 +1,196 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+
+import type { ProviderId } from '@lzdi/pty-remote-protocol/runtime-types.ts';
+
+export interface UploadAttachmentInput {
+  contentBase64: string;
+  conversationKey: string | null;
+  cwd: string;
+  filename: string;
+  mimeType: string;
+  providerId: ProviderId;
+  sessionId: string | null;
+  size: number;
+}
+
+export interface UploadedAttachmentRecord {
+  attachmentId: string;
+  conversationKey: string | null;
+  cwd: string;
+  filename: string;
+  mimeType: string;
+  path: string;
+  providerId: ProviderId;
+  sessionId: string | null;
+  size: number;
+  status: 'pending' | 'sent';
+  createdAt: number;
+}
+
+const ATTACHMENT_MAX_BYTES = 4 * 1024 * 1024;
+const ATTACHMENT_PENDING_TTL_MS = 30 * 60 * 1000;
+const ATTACHMENT_CLEANUP_INTERVAL_MS = 5 * 60 * 1000;
+
+function sanitizeSegment(value: string): string {
+  const trimmed = value.trim();
+  const normalized = trimmed.replace(/[/\\?%*:|"<>]/g, '-').replace(/\s+/g, '-');
+  return normalized.slice(0, 80) || 'attachment';
+}
+
+function sanitizeFilename(filename: string): string {
+  return sanitizeSegment(filename).replace(/\.\.+/g, '.');
+}
+
+function estimateBase64Bytes(base64: string): number {
+  const len = base64.length;
+  if (len === 0) {
+    return 0;
+  }
+  const padding = base64.endsWith('==') ? 2 : base64.endsWith('=') ? 1 : 0;
+  return Math.floor((len * 3) / 4) - padding;
+}
+
+function createConversationDirectoryName(input: {
+  conversationKey: string | null;
+  cwd: string;
+  sessionId: string | null;
+}): string {
+  const basis = input.conversationKey ?? input.sessionId ?? input.cwd;
+  const hash = createHash('sha1').update(basis).digest('hex').slice(0, 12);
+  const label = sanitizeSegment(path.basename(input.cwd) || (input.conversationKey ?? input.sessionId ?? 'draft'));
+  return `${label}-${hash}`;
+}
+
+export class AttachmentManager {
+  private readonly attachments = new Map<string, UploadedAttachmentRecord>();
+
+  private readonly rootDir = path.join(os.homedir(), '.pty-remote', 'uploads');
+
+  private cleanupTimer: NodeJS.Timeout | null = null;
+
+  start(): void {
+    if (this.cleanupTimer) {
+      return;
+    }
+
+    this.cleanupTimer = setInterval(() => {
+      void this.cleanupExpiredPending();
+    }, ATTACHMENT_CLEANUP_INTERVAL_MS);
+  }
+
+  stop(): void {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = null;
+    }
+  }
+
+  async uploadAttachment(input: UploadAttachmentInput): Promise<UploadedAttachmentRecord> {
+    const estimatedBytes = estimateBase64Bytes(input.contentBase64);
+    if (estimatedBytes > ATTACHMENT_MAX_BYTES || input.size > ATTACHMENT_MAX_BYTES) {
+      throw new Error('图片不能超过 4MB');
+    }
+
+    const attachmentId = randomUUID();
+    const directory = path.join(
+      this.rootDir,
+      input.providerId,
+      createConversationDirectoryName({
+        conversationKey: input.conversationKey,
+        cwd: input.cwd,
+        sessionId: input.sessionId
+      })
+    );
+    const filename = `${Date.now()}-${attachmentId}-${sanitizeFilename(input.filename)}`;
+    const filePath = path.join(directory, filename);
+    const buffer = Buffer.from(input.contentBase64, 'base64');
+
+    if (buffer.length > ATTACHMENT_MAX_BYTES) {
+      throw new Error('图片不能超过 4MB');
+    }
+
+    await mkdir(directory, { recursive: true });
+    await writeFile(filePath, buffer);
+
+    const record: UploadedAttachmentRecord = {
+      attachmentId,
+      conversationKey: input.conversationKey,
+      cwd: input.cwd,
+      createdAt: Date.now(),
+      filename: input.filename,
+      mimeType: input.mimeType,
+      path: filePath,
+      providerId: input.providerId,
+      sessionId: input.sessionId,
+      size: input.size,
+      status: 'pending'
+    };
+
+    this.attachments.set(attachmentId, record);
+    return record;
+  }
+
+  async deleteAttachment(attachmentId: string): Promise<void> {
+    const record = this.attachments.get(attachmentId);
+    if (!record) {
+      return;
+    }
+
+    this.attachments.delete(attachmentId);
+    await rm(record.path, { force: true }).catch(() => undefined);
+  }
+
+  markReferencedPathsAsSent(content: string): void {
+    for (const record of this.attachments.values()) {
+      if (record.status === 'sent') {
+        continue;
+      }
+      if (content.includes(`@${record.path}`)) {
+        record.status = 'sent';
+      }
+    }
+  }
+
+  async cleanupConversation(target: {
+    conversationKey: string | null;
+    cwd: string;
+    providerId: ProviderId;
+    sessionId: string | null;
+  }): Promise<void> {
+    const removals = [...this.attachments.values()].filter(
+      (record) =>
+        record.providerId === target.providerId &&
+        record.cwd === target.cwd &&
+        record.conversationKey === target.conversationKey &&
+        record.sessionId === target.sessionId
+    );
+
+    await Promise.all(removals.map((record) => this.deleteAttachment(record.attachmentId)));
+  }
+
+  async cleanupProject(target: { cwd: string; providerId: ProviderId }): Promise<void> {
+    const removals = [...this.attachments.values()].filter(
+      (record) => record.providerId === target.providerId && record.cwd === target.cwd
+    );
+
+    await Promise.all(removals.map((record) => this.deleteAttachment(record.attachmentId)));
+  }
+
+  async cleanupExpiredPending(): Promise<void> {
+    const cutoff = Date.now() - ATTACHMENT_PENDING_TTL_MS;
+    const removals = [...this.attachments.values()].filter(
+      (record) => record.status === 'pending' && record.createdAt < cutoff
+    );
+
+    await Promise.all(removals.map((record) => this.deleteAttachment(record.attachmentId)));
+  }
+
+  async shutdown(): Promise<void> {
+    this.stop();
+    const removals = [...this.attachments.values()].map((record) => this.deleteAttachment(record.attachmentId));
+    await Promise.all(removals);
+  }
+}

package/src/cli/cli-config.ts

@@ -0,0 +1,58 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const ROOT_DIR = path.resolve(__dirname, '../..');
+const USER_CONFIG_DIR = path.join(os.homedir(), '.pty-remote');
+const USER_CONFIG_PATH = path.join(USER_CONFIG_DIR, 'cli.conf');
+const TEMPLATE_PATH = path.join(ROOT_DIR, 'cli.conf');
+function ensureCliConfigFile(): string {
+  try {
+    if (!existsSync(USER_CONFIG_PATH)) {
+      if (existsSync(TEMPLATE_PATH)) {
+        mkdirSync(USER_CONFIG_DIR, { recursive: true });
+        copyFileSync(TEMPLATE_PATH, USER_CONFIG_PATH);
+      }
+    }
+  } catch {
+    // Fall back to environment defaults if we cannot create/read the config file.
+  }
+  return USER_CONFIG_PATH;
+}
+
+function parseConfig(raw: string): Record<string, string> {
+  const entries: Record<string, string> = {};
+  const lines = raw.split(/\r?\n/);
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) {
+      continue;
+    }
+    const [key, ...rest] = trimmed.split('=');
+    if (!key) {
+      continue;
+    }
+    const value = rest.join('=').trim();
+    if (!value) {
+      continue;
+    }
+    entries[key.trim()] = value;
+  }
+  return entries;
+}
+
+export function loadCliConfig(): Record<string, string> {
+  const configPath = ensureCliConfigFile();
+  if (!existsSync(configPath)) {
+    return {};
+  }
+  try {
+    const raw = readFileSync(configPath, 'utf8');
+    return parseConfig(raw);
+  } catch {
+    return {};
+  }
+}