chatccc 0.2.272 → 0.2.276

package/dist/deepccc-agent/src/attachments.js

@@ -0,0 +1,192 @@
+import { randomUUID } from "node:crypto";
+import { mkdir, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { basename, join, resolve } from "node:path";
+import { DEEPCCC_HOME } from "./config.js";
+import { normalizeBuiltinSessionId } from "./context.js";
+export const MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+export const MAX_ATTACHMENTS_PER_MESSAGE = 10;
+export const ATTACHMENT_PROMPT_START = "<deepccc-attachments>";
+export const ATTACHMENT_PROMPT_END = "</deepccc-attachments>";
+export class AttachmentStore {
+    rootDir;
+    idFactory;
+    constructor(options = {}) {
+        this.rootDir = resolve(options.rootDir ?? join(DEEPCCC_HOME, "attachments"));
+        this.idFactory = options.idFactory ?? (() => randomUUID());
+    }
+    async save(sessionId, input) {
+        const bytes = Buffer.from(input.bytes);
+        if (!bytes.length)
+            throw new Error("Image attachment must not be empty");
+        if (bytes.length > MAX_ATTACHMENT_BYTES)
+            throw new Error("Image attachment exceeds the 20 MB limit");
+        const mimeType = detectImageMime(bytes);
+        if (!mimeType)
+            throw new Error("Only PNG, JPEG, or WebP image attachments are supported");
+        const normalizedSessionId = normalizeBuiltinSessionId(sessionId);
+        const attachmentId = normalizeAttachmentId(this.idFactory());
+        const extension = extensionForMime(mimeType);
+        const fileName = `${attachmentId}${extension}`;
+        const sessionDir = this.sessionDir(normalizedSessionId);
+        const absolutePath = join(sessionDir, fileName);
+        const meta = {
+            attachmentId,
+            originalName: cleanOriginalName(input.originalName, extension),
+            mimeType,
+            size: bytes.length,
+            absolutePath,
+            fileName,
+        };
+        await mkdir(sessionDir, { recursive: true });
+        const dataTemp = `${absolutePath}.${process.pid}.tmp`;
+        const metaPath = this.metaPath(normalizedSessionId, attachmentId);
+        const metaTemp = `${metaPath}.${process.pid}.tmp`;
+        await writeFile(dataTemp, bytes);
+        await rename(dataTemp, absolutePath);
+        await writeFile(metaTemp, `${JSON.stringify(meta, null, 2)}\n`, "utf8");
+        await rename(metaTemp, metaPath);
+        return publicMeta(meta);
+    }
+    async importFile(sessionId, path) {
+        const absolutePath = resolve(path);
+        const info = await stat(absolutePath).catch(() => null);
+        if (!info?.isFile())
+            throw new Error(`Image attachment not found: ${path}`);
+        if (info.size > MAX_ATTACHMENT_BYTES)
+            throw new Error(`Image attachment exceeds the 20 MB limit: ${path}`);
+        return this.save(sessionId, {
+            originalName: basename(absolutePath),
+            bytes: await readFile(absolutePath),
+        });
+    }
+    async get(sessionId, attachmentId) {
+        const stored = await this.readStored(sessionId, attachmentId);
+        return stored ? publicMeta(stored) : null;
+    }
+    async read(sessionId, attachmentId) {
+        const stored = await this.readStored(sessionId, attachmentId);
+        if (!stored)
+            return null;
+        try {
+            const bytes = await readFile(stored.absolutePath);
+            if (bytes.length !== stored.size || detectImageMime(bytes) !== stored.mimeType)
+                return null;
+            return { attachment: publicMeta(stored), bytes };
+        }
+        catch {
+            return null;
+        }
+    }
+    async delete(sessionId, attachmentId) {
+        const stored = await this.readStored(sessionId, attachmentId);
+        if (!stored)
+            return false;
+        await Promise.all([
+            unlink(stored.absolutePath).catch(() => { }),
+            unlink(this.metaPath(sessionId, attachmentId)).catch(() => { }),
+        ]);
+        return true;
+    }
+    async deleteSession(sessionId) {
+        await rm(this.sessionDir(sessionId), { recursive: true, force: true });
+    }
+    async readStored(sessionId, attachmentId) {
+        const normalizedId = normalizeAttachmentId(attachmentId);
+        try {
+            const value = JSON.parse(await readFile(this.metaPath(sessionId, normalizedId), "utf8"));
+            if (value.attachmentId !== normalizedId || typeof value.fileName !== "string")
+                return null;
+            if (typeof value.originalName !== "string" || typeof value.size !== "number")
+                return null;
+            if (value.mimeType !== "image/png" && value.mimeType !== "image/jpeg" && value.mimeType !== "image/webp")
+                return null;
+            if (value.fileName !== `${normalizedId}${extensionForMime(value.mimeType)}`)
+                return null;
+            const absolutePath = join(this.sessionDir(sessionId), value.fileName);
+            return { ...value, absolutePath };
+        }
+        catch {
+            return null;
+        }
+    }
+    sessionDir(sessionId) {
+        return join(this.rootDir, normalizeBuiltinSessionId(sessionId));
+    }
+    metaPath(sessionId, attachmentId) {
+        return join(this.sessionDir(sessionId), `${normalizeAttachmentId(attachmentId)}.json`);
+    }
+}
+export function buildAttachmentPrompt(text, attachments) {
+    const prompt = text.trim() || "请分析这些图片。";
+    if (!attachments.length)
+        return prompt;
+    const manifest = attachments.map((attachment) => ({
+        attachmentId: attachment.attachmentId,
+        originalName: attachment.originalName,
+        mimeType: attachment.mimeType,
+        size: attachment.size,
+        absolutePath: attachment.absolutePath,
+    }));
+    return [
+        prompt,
+        "",
+        ATTACHMENT_PROMPT_START,
+        JSON.stringify(manifest),
+        ATTACHMENT_PROMPT_END,
+        "以上图片以本地附件文件提供。不要假设模型原生支持图片；请使用可用工具读取这些绝对路径并自行处理。",
+    ].join("\n");
+}
+export function parseAttachmentPrompt(content) {
+    const start = content.indexOf(ATTACHMENT_PROMPT_START);
+    const end = content.indexOf(ATTACHMENT_PROMPT_END, start + ATTACHMENT_PROMPT_START.length);
+    if (start < 0 || end < 0)
+        return { text: content, attachments: [] };
+    const raw = content.slice(start + ATTACHMENT_PROMPT_START.length, end).trim();
+    let attachments = [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (Array.isArray(parsed))
+            attachments = parsed.filter(isAttachmentMeta);
+    }
+    catch {
+        return { text: content, attachments: [] };
+    }
+    return { text: content.slice(0, start).trimEnd(), attachments };
+}
+export function detectImageMime(bytes) {
+    const buffer = Buffer.from(bytes);
+    if (buffer.length >= 8 && buffer.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
+        return "image/png";
+    if (buffer.length >= 3 && buffer[0] === 0xff && buffer[1] === 0xd8 && buffer[2] === 0xff)
+        return "image/jpeg";
+    if (buffer.length >= 12 && buffer.subarray(0, 4).toString("ascii") === "RIFF" && buffer.subarray(8, 12).toString("ascii") === "WEBP")
+        return "image/webp";
+    return null;
+}
+function extensionForMime(mimeType) {
+    return mimeType === "image/png" ? ".png" : mimeType === "image/jpeg" ? ".jpg" : ".webp";
+}
+function cleanOriginalName(value, extension) {
+    const cleaned = basename(value || `image${extension}`).replace(/[\u0000-\u001f<>:"/\\|?*]+/g, "_").slice(0, 180);
+    return cleaned || `image${extension}`;
+}
+function normalizeAttachmentId(value) {
+    const normalized = value.replace(/[^a-zA-Z0-9_.-]+/g, "_").replace(/^_+|_+$/g, "");
+    if (!normalized || normalized === "." || normalized === "..")
+        throw new Error("Invalid attachment id");
+    return normalized;
+}
+function publicMeta(value) {
+    const { fileName: _, ...meta } = value;
+    return meta;
+}
+function isAttachmentMeta(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return false;
+    const attachment = value;
+    return typeof attachment.attachmentId === "string"
+        && typeof attachment.originalName === "string"
+        && typeof attachment.absolutePath === "string"
+        && typeof attachment.size === "number"
+        && (attachment.mimeType === "image/png" || attachment.mimeType === "image/jpeg" || attachment.mimeType === "image/webp");
+}

package/dist/deepccc-agent/src/cli.js

@@ -2,9 +2,9 @@
  * DeepCCC terminal REPL and JSONL streaming entrypoint — 同步自 ChatCCC
  *
  * Usage:
- *   node bin/deepccc.mjs
- *   node bin/deepccc.mjs --model deepseek-v4-pro
- *   node bin/deepccc.mjs --stream-json --prompt "hello"
+ *   node bin/deepccc-cli.mjs
+ *   node bin/deepccc-cli.mjs --model deepseek-v4-pro
+ *   node bin/deepccc-cli.mjs --stream-json --prompt "hello"
  *
  * 交互模式（TTY）下，单轮回复渲染为固定"过程区块"：状态行 + 折叠工具行 +
  * 原地更新正文，不再滚屏刷 JSON；完成/停止/异常后定型留在屏幕上。
@@ -24,6 +24,7 @@ import { reduceProgress } from "./progress/reducer.js";
 import { TerminalProgressRenderer } from "./progress/terminal-renderer.js";
 import { progressView } from "./progress/view.js";
 import { defaultLogDir, setupFileLogging } from "./file-log.js";
+import { AttachmentStore, buildAttachmentPrompt } from "./attachments.js";
 function parsePositiveIntegerOption(name, value) {
     const parsed = Number(value);
     if (!Number.isInteger(parsed) || parsed <= 0) {
@@ -46,6 +47,7 @@ function parseArgs(argv = process.argv.slice(2)) {
     let streamJson = false;
     let prompt = null;
     let plain = false;
+    const images = [];
     for (let i = 0; i < argv.length; i++) {
         const arg = argv[i];
         const next = argv[i + 1];
@@ -104,6 +106,10 @@ function parseArgs(argv = process.argv.slice(2)) {
             prompt = next;
             i++;
         }
+        else if (arg === "--image" && next !== undefined) {
+            images.push(next);
+            i++;
+        }
         else if (arg === "--plain") {
             plain = true;
         }
@@ -115,7 +121,7 @@ function parseArgs(argv = process.argv.slice(2)) {
             help = true;
         }
     }
-    return { config, options, listSessions, resume, help, streamJson, prompt, plain };
+    return { config, options, listSessions, resume, help, streamJson, prompt, images, plain };
 }
 async function loadRuntime() {
     const [{ ChatSession }, { config: appConfig }] = await Promise.all([
@@ -128,7 +134,7 @@ function printHelp(appConfig) {
     console.log([
         "DeepCCC terminal agent",
         "",
-        "Usage: deepccc [options]",
+        "Usage: deepccc-cli [options]",
         "",
         "Options:",
         `  --provider <name>    API protocol: openai or anthropic (current default ${appConfig.provider})`,
@@ -144,6 +150,7 @@ function printHelp(appConfig) {
         "  --list-sessions      List saved sessions and exit",
         "  --stream-json        One-shot mode: write JSONL events to stdout",
         "  --prompt <text>      Prompt text for --stream-json",
+        "  --image <path>      Attach a PNG/JPEG/WebP file (repeatable; copied to the session attachment store)",
         "  --plain              Force plain streaming output (no progress block renderer)",
         "  --dangerously-bypass-permissions  Skip all permission prompts (aligns with chatccc's bypass mode)",
         "  --help, -h           Show help",
@@ -276,8 +283,8 @@ async function runStreamJson(args) {
         return 0;
     }
     const prompt = args.prompt ?? (!process.stdin.isTTY ? await readPromptFromStdin() : "");
-    if (!prompt.trim()) {
-        writeJsonLine({ type: "error", message: "--stream-json requires --prompt <text> or stdin input" });
+    if (!prompt.trim() && !args.images.length) {
+        writeJsonLine({ type: "error", message: "--stream-json requires --prompt <text>, stdin input, or --image <path>" });
         return 1;
     }
     let runtime;
@@ -310,15 +317,29 @@ async function runStreamJson(args) {
         writeJsonLine({ type: "error", message: err.message });
         return 1;
     }
+    let attachments;
+    try {
+        attachments = await importCliAttachments(resolvedSession.sessionId, args.images);
+    }
+    catch (err) {
+        writeJsonLine({ type: "error", message: err.message });
+        return 1;
+    }
+    const promptWithAttachments = buildAttachmentPrompt(prompt, attachments);
     writeJsonLine({
         type: "start",
         session_id: resolvedSession.sessionId,
         mode: resolvedSession.mode,
         cwd,
         model: args.config.model ?? runtime.appConfig.model,
+        attachments: attachments.map((attachment) => ({
+            attachment_id: attachment.attachmentId,
+            name: attachment.originalName,
+            path: attachment.absolutePath,
+        })),
     });
     try {
-        for await (const event of session.chat(prompt)) {
+        for await (const event of session.chat(promptWithAttachments)) {
             streamJsonEvent(event);
         }
         return 0;
@@ -425,13 +446,24 @@ async function runRepl(args) {
         console.error(`${C.yellow}${err.message}${C.reset}`);
         process.exit(1);
     }
+    let pendingAttachments;
+    try {
+        pendingAttachments = await importCliAttachments(resolvedSession.sessionId, args.images);
+    }
+    catch (err) {
+        console.error(`${C.yellow}${err.message}${C.reset}`);
+        process.exit(1);
+    }
+    if (pendingAttachments.length) {
+        console.log(`${C.dim}Attachments queued: ${pendingAttachments.map((attachment) => attachment.originalName).join(", ")}${C.reset}`);
+    }
     let currentAbort = null;
     const ctrlCState = createCtrlCState();
     rl.prompt();
     rl.on("line", async (line) => {
         ctrlCState.reset();
         const input = line.trim();
-        if (!input) {
+        if (!input && !pendingAttachments.length) {
             rl.prompt();
             return;
         }
@@ -475,8 +507,10 @@ async function runRepl(args) {
         }
         let rendererEnded = false;
         try {
+            const chatInput = buildAttachmentPrompt(input, pendingAttachments);
+            pendingAttachments = [];
             let lastAccumulated = "";
-            for await (const event of session.chat(input, signal)) {
+            for await (const event of session.chat(chatInput, signal)) {
                 if (renderer && view) {
                     view = reduceProgress(view, event);
                     if (event.type === "text" || event.type === "compact" || event.type === "status") {
@@ -564,8 +598,15 @@ async function runRepl(args) {
         process.exit(0);
     });
 }
+async function importCliAttachments(sessionId, paths) {
+    const store = new AttachmentStore();
+    const attachments = [];
+    for (const path of paths)
+        attachments.push(await store.importFile(sessionId, path));
+    return attachments;
+}
 /**
- * skill create 子命令：deepccc skill create <name> [--scope global|project] [--description "..."]
+ * skill create 子命令：deepccc-cli skill create <name> [--scope global|project] [--description "..."]
  * 默认创建为全局技能（~/.deepccc/skills/<name>/SKILL.md，Codex 结构）；
  * --scope project 创建为项目技能（<cwd>/.deepccc/skills/<name>/SKILL.md）。
  * 新技能在下一次对话自动生效（技能索引每次 chat() 前重扫）。
@@ -574,7 +615,7 @@ function runSkillCreate(argv) {
     const positional = argv.filter((a) => !a.startsWith("--"));
     const name = positional[0];
     if (!name) {
-        console.error("usage: deepccc skill create <name> [--scope global|project] [--description \"...\"]");
+        console.error("usage: deepccc-cli skill create <name> [--scope global|project] [--description \"...\"]");
         process.exit(1);
     }
     if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(name)) {
@@ -608,7 +649,7 @@ function runSkillCreate(argv) {
     console.log("hot reload: 下一次对话自动生效，无需重启");
 }
 async function main() {
-    // skill create 子命令：deepccc skill create <name> [--scope global|project] [--description "..."]
+    // skill create 子命令：deepccc-cli skill create <name> [--scope global|project] [--description "..."]
     // 默认创建在全局 ~/.deepccc/skills（Codex 目录结构），--scope project 创建到 <cwd>/.deepccc/skills。
     if (process.argv[2] === "skill" && process.argv[3] === "create") {
         runSkillCreate(process.argv.slice(4));

package/dist/deepccc-agent/src/config.js

@@ -1,9 +1,9 @@
-import { existsSync, mkdirSync, readFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
 export const DEEPCCC_HOME = join(homedir(), ".deepccc");
 export const RAW_STREAM_LOGS_DIR = join(DEEPCCC_HOME, "raw-stream-logs");
-const CONFIG_PATH = join(DEEPCCC_HOME, "config.json");
+export const CONFIG_PATH = join(DEEPCCC_HOME, "config.json");
 /**
  * 默认配置（不读环境/文件）。导出供测试断言默认值；运行时请用 loadConfig 结果。
  */
@@ -31,8 +31,12 @@ export const DEFAULT_CONFIG = {
         retentionDays: 7,
         keepCompleted: false,
     },
+    web: {
+        port: 28_080,
+        openOnStart: true,
+    },
 };
-function readConfigFile() {
+export function readConfigFile() {
     if (!existsSync(CONFIG_PATH))
         return {};
     const raw = JSON.parse(readFileSync(CONFIG_PATH, "utf8"));
@@ -70,13 +74,14 @@ export function normalizeDeepCccProvider(value) {
         return normalized;
     throw new Error(`DEEPCCC_PROVIDER/provider must be "openai" or "anthropic", received: ${String(value)}`);
 }
-function loadConfig() {
+export function loadConfig() {
     const file = readConfigFile();
     const rawLogs = file.rawStreamLogs && typeof file.rawStreamLogs === "object"
         ? file.rawStreamLogs
         : {};
     const git = file.git && typeof file.git === "object" ? file.git : {};
     const coAuthor = git.coAuthor && typeof git.coAuthor === "object" ? git.coAuthor : {};
+    const web = file.web && typeof file.web === "object" ? file.web : {};
     return {
         provider: normalizeDeepCccProvider(env("DEEPCCC_PROVIDER") ?? file.provider ?? DEFAULT_CONFIG.provider),
         apiKey: env("DEEPCCC_API_KEY") ?? env("DEEPSEEK_API_KEY") ?? file.apiKey ?? DEFAULT_CONFIG.apiKey,
@@ -101,9 +106,49 @@ function loadConfig() {
             retentionDays: numberEnv("DEEPCCC_RAW_STREAM_RETENTION_DAYS") ?? rawLogs.retentionDays ?? DEFAULT_CONFIG.rawStreamLogs.retentionDays,
             keepCompleted: boolEnv("DEEPCCC_RAW_STREAM_KEEP_COMPLETED") ?? rawLogs.keepCompleted ?? DEFAULT_CONFIG.rawStreamLogs.keepCompleted,
         },
+        web: {
+            port: normalizeWebPort(web.port),
+            openOnStart: web.openOnStart ?? DEFAULT_CONFIG.web.openOnStart,
+        },
     };
 }
 export function ensureConfigDir() {
     mkdirSync(dirname(CONFIG_PATH), { recursive: true });
 }
+/** Persist only user-editable Web fields while preserving advanced configuration. */
+export function saveConfigPatch(patch) {
+    const existing = readConfigFile();
+    const { web: webPatch, ...flatPatch } = patch;
+    const next = {
+        ...existing,
+        ...flatPatch,
+        ...(webPatch ? { web: { ...DEFAULT_CONFIG.web, ...(existing.web ?? {}), ...webPatch } } : {}),
+    };
+    if (patch.provider !== undefined)
+        next.provider = normalizeDeepCccProvider(patch.provider);
+    if (patch.baseURL !== undefined && !patch.baseURL.trim())
+        throw new Error("baseURL must not be empty");
+    if (patch.model !== undefined && !patch.model.trim())
+        throw new Error("model must not be empty");
+    if (patch.effort !== undefined && !["", "none", "minimal", "low", "medium", "high", "xhigh", "max"].includes(patch.effort)) {
+        throw new Error(`Unsupported effort: ${patch.effort}`);
+    }
+    if (patch.contextWindow !== undefined && (!Number.isInteger(patch.contextWindow) || patch.contextWindow <= 0)) {
+        throw new Error("contextWindow must be a positive integer");
+    }
+    if (webPatch?.port !== undefined) {
+        next.web = { ...(next.web ?? DEFAULT_CONFIG.web), port: normalizeWebPort(webPatch.port) };
+    }
+    ensureConfigDir();
+    const tempPath = `${CONFIG_PATH}.${process.pid}.tmp`;
+    writeFileSync(tempPath, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    renameSync(tempPath, CONFIG_PATH);
+    return loadConfig();
+}
+function normalizeWebPort(value) {
+    const parsed = Number(value ?? DEFAULT_CONFIG.web.port);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65_535)
+        return DEFAULT_CONFIG.web.port;
+    return parsed;
+}
 export const config = loadConfig();