@templmf/temp-solf-lmf 0.0.162 → 0.0.164

package/aws/README.md

@@ -0,0 +1,70 @@
+# S3 Bucket Explorer
+
+基于 `aws-java-sdk-s3` (1.12.194) 编写的小工具，用于探查/解析 S3 bucket 中的对象数据。
+
+## 构建
+
+```bash
+mvn clean package
+```
+
+构建完成后会在 `target/` 目录生成一个包含全部依赖的可执行 jar：
+`target/s3-bucket-parser-1.0.0.jar`
+
+## 使用
+
+### 1. 列出 bucket 下的对象
+
+```bash
+java -jar target/s3-bucket-parser-1.0.0.jar list \
+  --bucket my-bucket \
+  --prefix logs/2026/ \
+  --region ap-northeast-1
+```
+
+### 2. 读取单个对象内容（自动识别并格式化 JSON）
+
+```bash
+java -jar target/s3-bucket-parser-1.0.0.jar read \
+  --bucket my-bucket \
+  --key logs/2026/09/10/data.json \
+  --region ap-northeast-1
+```
+
+### 3. 体检/诊断对象（排查为什么读出来是二进制）
+
+```bash
+java -jar target/s3-bucket-parser-1.0.0.jar inspect \
+  --bucket my-bucket \
+  --key logs/2026/09/10/data.bin \
+  --region ap-northeast-1
+```
+
+会打印：Content-Type / Content-Encoding / 是否有服务端加密（SSE）/ 自定义元数据，
+以及内容开头 64 字节的十六进制 + ASCII 对照视图，并根据文件头 magic number
+自动猜测格式（gzip / zip / parquet / png / jpeg / pdf / 明文 JSON / 明文文本 /
+加密或自定义二进制格式）。
+
+### 4. 批量下载对象到本地
+
+```bash
+java -jar target/s3-bucket-parser-1.0.0.jar download \
+  --bucket my-bucket \
+  --prefix logs/2026/ \
+  --out ./downloaded \
+  --region ap-northeast-1
+```
+
+## 认证方式（三选一）
+
+1. **默认凭证链**（推荐）：不传任何认证参数，SDK 会依次尝试环境变量
+   （`AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`）、`~/.aws/credentials`、
+   EC2/ECS/Lambda 角色等。
+2. **指定 profile**：`--profile myprofile`，对应 `~/.aws/credentials` 中的配置段。
+3. **直接传 AK/SK**（仅建议本地临时测试）：`--access-key xxx --secret-key yyy`。
+
+## 说明
+
+- 已针对 `ListObjectsV2` 做了分页处理，可以安全用于对象数量很大的 bucket。
+- `read` 命令会尝试把内容解析成 JSON 并美化打印；如果不是合法 JSON，则原样打印文本内容。
+- 如果对象是二进制文件（如图片、压缩包），建议直接用 `download` 命令而不是 `read`。

package/aws/S3BucketExplorer.java

@@ -0,0 +1,371 @@
+package com.example.s3tool;
+
+import com.amazonaws.auth.AWSStaticCredentialsProvider;
+import com.amazonaws.auth.BasicAWSCredentials;
+import com.amazonaws.auth.profile.ProfileCredentialsProvider;
+import com.amazonaws.services.s3.AmazonS3;
+import com.amazonaws.services.s3.AmazonS3ClientBuilder;
+import com.amazonaws.services.s3.model.ListObjectsV2Request;
+import com.amazonaws.services.s3.model.ListObjectsV2Result;
+import com.amazonaws.services.s3.model.ObjectMetadata;
+import com.amazonaws.services.s3.model.S3Object;
+import com.amazonaws.services.s3.model.S3ObjectSummary;
+import com.fasterxml.jackson.databind.JsonNode;
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.time.format.DateTimeFormatter;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * S3 Bucket 数据探查/解析小工具。
+ *
+ * 功能：
+ *  1. 列出 bucket（可按前缀过滤）下的所有对象，打印 key / 大小 / 最后修改时间
+ *  2. 读取指定对象内容并打印（自动识别 JSON 并格式化）
+ *  3. 批量下载 bucket（或某前缀）下的所有对象到本地目录
+ *
+ * 用法：
+ *   list      列出对象
+ *     java -jar s3-bucket-parser.jar list --bucket my-bucket [--prefix logs/] [--region ap-northeast-1] [--profile myprofile]
+ *
+ *   read      读取单个对象内容并打印
+ *     java -jar s3-bucket-parser.jar read --bucket my-bucket --key path/to/file.json [--region ap-northeast-1]
+ *
+ *   download  批量下载
+ *     java -jar s3-bucket-parser.jar download --bucket my-bucket [--prefix logs/] --out ./downloaded [--region ap-northeast-1]
+ *
+ * 认证方式（任选其一）：
+ *   - 不传 --profile / --access-key 时，使用默认凭证链（环境变量 / ~/.aws/credentials / EC2、ECS 角色等）
+ *   - 传 --profile 指定 ~/.aws/credentials 中的某个 profile
+ *   - 传 --access-key 和 --secret-key 直接指定（不推荐用于生产环境，仅方便本地测试）
+ */
+public class S3BucketExplorer {
+
+    public static void main(String[] args) {
+        if (args.length == 0) {
+            printUsageAndExit();
+        }
+
+        String command = args[0];
+        Args parsed = Args.parse(args, 1);
+
+        String bucket = parsed.get("bucket");
+        if (bucket == null) {
+            System.err.println("错误：必须通过 --bucket 指定存储桶名称");
+            printUsageAndExit();
+        }
+
+        String region = parsed.getOrDefault("region", "ap-northeast-1");
+        AmazonS3 s3 = buildClient(parsed, region);
+
+        try {
+            switch (command) {
+                case "list":
+                    listObjects(s3, bucket, parsed.get("prefix"));
+                    break;
+                case "read":
+                    String key = parsed.get("key");
+                    if (key == null) {
+                        System.err.println("错误：read 命令必须通过 --key 指定对象 key");
+                        printUsageAndExit();
+                    }
+                    readObject(s3, bucket, key);
+                    break;
+                case "inspect":
+                    String inspectKey = parsed.get("key");
+                    if (inspectKey == null) {
+                        System.err.println("错误：inspect 命令必须通过 --key 指定对象 key");
+                        printUsageAndExit();
+                    }
+                    inspectObject(s3, bucket, inspectKey);
+                    break;
+                case "download":
+                    String outDir = parsed.getOrDefault("out", "./downloaded");
+                    downloadAll(s3, bucket, parsed.get("prefix"), outDir);
+                    break;
+                default:
+                    System.err.println("未知命令: " + command);
+                    printUsageAndExit();
+            }
+        } finally {
+            s3.shutdown();
+        }
+    }
+
+    /** 构建 S3 客户端，按优先级选择凭证方式 */
+    private static AmazonS3 buildClient(Args parsed, String region) {
+        AmazonS3ClientBuilder builder = AmazonS3ClientBuilder.standard().withRegion(region);
+
+        String accessKey = parsed.get("access-key");
+        String secretKey = parsed.get("secret-key");
+        String profile = parsed.get("profile");
+
+        if (accessKey != null && secretKey != null) {
+            builder.withCredentials(new AWSStaticCredentialsProvider(
+                    new BasicAWSCredentials(accessKey, secretKey)));
+        } else if (profile != null) {
+            builder.withCredentials(new ProfileCredentialsProvider(profile));
+        }
+        // 都不传则走默认凭证链（DefaultAWSCredentialsProviderChain）
+
+        return builder.build();
+    }
+
+    /** 列出 bucket 下的对象，自动处理分页 */
+    private static void listObjects(AmazonS3 s3, String bucket, String prefix) {
+        System.out.printf("正在列出 bucket=%s prefix=%s 下的对象...%n%n", bucket, prefix == null ? "(全部)" : prefix);
+
+        DateTimeFormatter fmt = DateTimeFormatter.ISO_INSTANT;
+        long totalCount = 0;
+        long totalSize = 0;
+
+        ListObjectsV2Request request = new ListObjectsV2Request()
+                .withBucketName(bucket)
+                .withPrefix(prefix)
+                .withMaxKeys(1000);
+
+        ListObjectsV2Result result;
+        System.out.println(padRight("KEY", 60) + padRight("SIZE(bytes)", 15) + "LAST MODIFIED");
+        System.out.println("-".repeat(100));
+
+        do {
+            result = s3.listObjectsV2(request);
+            for (S3ObjectSummary summary : result.getObjectSummaries()) {
+                System.out.println(
+                        padRight(summary.getKey(), 60)
+                                + padRight(String.valueOf(summary.getSize()), 15)
+                                + fmt.format(summary.getLastModified().toInstant())
+                );
+                totalCount++;
+                totalSize += summary.getSize();
+            }
+            request.setContinuationToken(result.getNextContinuationToken());
+        } while (result.isTruncated());
+
+        System.out.println("-".repeat(100));
+        System.out.printf("共 %d 个对象，总大小 %.2f MB%n", totalCount, totalSize / 1024.0 / 1024.0);
+    }
+
+    /** 读取单个对象内容并打印，若能解析为 JSON 则格式化输出 */
+    private static void readObject(AmazonS3 s3, String bucket, String key) {
+        try (S3Object obj = s3.getObject(bucket, key)) {
+            ObjectMetadata meta = obj.getObjectMetadata();
+            System.out.printf("对象: s3://%s/%s%n", bucket, key);
+            System.out.printf("大小: %d bytes | Content-Type: %s%n%n", meta.getContentLength(), meta.getContentType());
+
+            String content = readAll(obj.getObjectContent());
+
+            // 尝试按 JSON 格式化，失败则原样打印为文本
+            try {
+                ObjectMapper mapper = new ObjectMapper();
+                JsonNode node = mapper.readTree(content);
+                System.out.println(mapper.writerWithDefaultPrettyPrinter().writeValueAsString(node));
+            } catch (IOException notJson) {
+                System.out.println(content);
+            }
+        } catch (IOException e) {
+            System.err.println("读取对象失败: " + e.getMessage());
+        }
+    }
+
+    /**
+     * “体检”一个对象：打印元数据（Content-Type / Content-Encoding / 自定义 x-amz-meta-*）
+     * 以及内容开头若干字节的十六进制 + ASCII 视图，并尝试根据 magic number 猜测真实格式。
+     * 用于排查“为什么读出来是二进制”这类问题，不需要猜测数据经过了什么处理。
+     */
+    private static void inspectObject(AmazonS3 s3, String bucket, String key) {
+        try (S3Object obj = s3.getObject(bucket, key)) {
+            ObjectMetadata meta = obj.getObjectMetadata();
+
+            System.out.printf("对象: s3://%s/%s%n", bucket, key);
+            System.out.println("-".repeat(60));
+            System.out.println("== 元数据 ==");
+            System.out.println("Content-Length   : " + meta.getContentLength());
+            System.out.println("Content-Type     : " + meta.getContentType());
+            System.out.println("Content-Encoding : " + meta.getContentEncoding()); // 若为 gzip，这里通常会显示 "gzip"
+            System.out.println("ETag             : " + meta.getETag());
+            System.out.println("SSE 算法          : " + meta.getSSEAlgorithm()); // 非 null 说明用了 SSE-S3/SSE-KMS 服务端加密
+
+            if (!meta.getUserMetadata().isEmpty()) {
+                System.out.println("自定义元数据(x-amz-meta-*):");
+                meta.getUserMetadata().forEach((k, v) -> System.out.println("  " + k + " = " + v));
+            }
+
+            System.out.println();
+            System.out.println("== 内容开头 64 字节 (hex / ascii) ==");
+            byte[] head = new byte[64];
+            int read;
+            try (InputStream in = obj.getObjectContent()) {
+                read = in.readNBytes(head, 0, head.length);
+            }
+            printHexDump(head, read);
+
+            System.out.println();
+            System.out.println("== 格式猜测 ==");
+            System.out.println(guessFormat(head, read));
+
+        } catch (IOException e) {
+            System.err.println("读取对象失败: " + e.getMessage());
+        }
+    }
+
+    /** 打印十六进制 + ASCII 对照视图，类似 `xxd` */
+    private static void printHexDump(byte[] data, int len) {
+        for (int offset = 0; offset < len; offset += 16) {
+            StringBuilder hex = new StringBuilder();
+            StringBuilder ascii = new StringBuilder();
+            int lineEnd = Math.min(offset + 16, len);
+            for (int i = offset; i < lineEnd; i++) {
+                hex.append(String.format("%02x ", data[i]));
+                char c = (char) (data[i] & 0xFF);
+                ascii.append(c >= 32 && c < 127 ? c : '.');
+            }
+            System.out.printf("%04x  %-48s  %s%n", offset, hex, ascii);
+        }
+    }
+
+    /** 根据文件头 magic number 猜测常见格式；识别不了的会提示如何进一步排查 */
+    private static String guessFormat(byte[] head, int len) {
+        if (len >= 2 && (head[0] & 0xFF) == 0x1f && (head[1] & 0xFF) == 0x8b) {
+            return "GZIP 压缩数据（很可能是写入前做了 gzip 压缩，需要先解压才能看到明文）";
+        }
+        if (len >= 4 && head[0] == 'P' && head[1] == 'K' && head[2] == 0x03 && head[3] == 0x04) {
+            return "ZIP 压缩包（可能是 zip，或基于 zip 的容器格式如 xlsx/docx/jar）";
+        }
+        if (len >= 4 && (head[0] & 0xFF) == 0x50 && (head[1] & 0xFF) == 0x41 && (head[2] & 0xFF) == 0x52 && (head[3] & 0xFF) == 0x31) {
+            return "Parquet 文件（文件头是 'PAR1'）";
+        }
+        if (len >= 8 && (head[0] & 0xFF) == 0x89 && head[1] == 'P' && head[2] == 'N' && head[3] == 'G') {
+            return "PNG 图片";
+        }
+        if (len >= 3 && (head[0] & 0xFF) == 0xFF && (head[1] & 0xFF) == 0xD8 && (head[2] & 0xFF) == 0xFF) {
+            return "JPEG 图片";
+        }
+        if (len >= 4 && head[0] == '%' && head[1] == 'P' && head[2] == 'D' && head[3] == 'F') {
+            return "PDF 文件";
+        }
+        if (len >= 1 && (head[0] == '{' || head[0] == '[')) {
+            return "很可能是 JSON 明文（以 { 或 [ 开头）";
+        }
+        boolean looksLikeText = true;
+        for (int i = 0; i < len; i++) {
+            int b = head[i] & 0xFF;
+            if (b == 9 || b == 10 || b == 13) continue; // tab/换行/回车
+            if (b < 32 || b > 126) {
+                looksLikeText = false;
+                break;
+            }
+        }
+        if (looksLikeText && len > 0) {
+            return "开头字节都在可打印 ASCII 范围内，很可能就是明文文本（如果整体看起来仍是乱码，也可能是明文但非 UTF-8 编码，比如 GBK）";
+        }
+        return "未识别出已知的文件头格式。字节分布随机、没有规律的话，通常意味着：\n"
+                + "  1) 经过了加密（客户端加密或 SSE-C/SSE-KMS 服务端加密返回的是密文，需要用对应密钥解密），或\n"
+                + "  2) 是某种自定义/私有的二进制序列化格式（如自定义 Protobuf/Thrift schema），需要对应的解析代码才能还原成明文。\n"
+                + "建议：对照写入这份数据的那一端代码（生产者/上传方），看看是否调用了加密或自定义序列化逻辑。";
+    }
+
+    /** 批量下载 bucket（或某前缀）下所有对象到本地目录，保持原有目录结构 */
+    private static void downloadAll(AmazonS3 s3, String bucket, String prefix, String outDir) {
+        List<String> keys = new ArrayList<>();
+
+        ListObjectsV2Request request = new ListObjectsV2Request()
+                .withBucketName(bucket)
+                .withPrefix(prefix)
+                .withMaxKeys(1000);
+        ListObjectsV2Result result;
+        do {
+            result = s3.listObjectsV2(request);
+            for (S3ObjectSummary summary : result.getObjectSummaries()) {
+                keys.add(summary.getKey());
+            }
+            request.setContinuationToken(result.getNextContinuationToken());
+        } while (result.isTruncated());
+
+        System.out.printf("共找到 %d 个对象，开始下载到 %s ...%n", keys.size(), outDir);
+
+        int done = 0;
+        for (String key : keys) {
+            try (S3Object obj = s3.getObject(bucket, key)) {
+                Path target = Paths.get(outDir, key);
+                Files.createDirectories(target.getParent() == null ? Paths.get(outDir) : target.getParent());
+                try (InputStream in = obj.getObjectContent()) {
+                    Files.copy(in, target, java.nio.file.StandardCopyOption.REPLACE_EXISTING);
+                }
+                done++;
+                if (done % 50 == 0 || done == keys.size()) {
+                    System.out.printf("已下载 %d/%d%n", done, keys.size());
+                }
+            } catch (IOException e) {
+                System.err.printf("下载失败 [%s]: %s%n", key, e.getMessage());
+            }
+        }
+        System.out.println("下载完成。");
+    }
+
+    private static String readAll(InputStream in) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8))) {
+            String line;
+            while ((line = reader.readLine()) != null) {
+                sb.append(line).append('\n');
+            }
+        }
+        return sb.toString();
+    }
+
+    private static String padRight(String s, int len) {
+        if (s.length() >= len) {
+            return s.substring(0, len - 1) + " ";
+        }
+        StringBuilder sb = new StringBuilder(s);
+        while (sb.length() < len) sb.append(' ');
+        return sb.toString();
+    }
+
+    private static void printUsageAndExit() {
+        System.out.println("用法:");
+        System.out.println("  list      java -jar s3-bucket-parser.jar list --bucket <bucket> [--prefix <prefix>] [--region <region>] [--profile <profile>]");
+        System.out.println("  read      java -jar s3-bucket-parser.jar read --bucket <bucket> --key <key> [--region <region>] [--profile <profile>]");
+        System.out.println("  inspect   java -jar s3-bucket-parser.jar inspect --bucket <bucket> --key <key> [--region <region>] [--profile <profile>]");
+        System.out.println("  download  java -jar s3-bucket-parser.jar download --bucket <bucket> [--prefix <prefix>] --out <local-dir> [--region <region>] [--profile <profile>]");
+        System.out.println();
+        System.out.println("认证：默认使用 AWS 默认凭证链；也可传 --profile <name>，或 --access-key/--secret-key（仅建议本地测试用）");
+        System.exit(1);
+    }
+
+    /** 极简命令行参数解析：--key value --key2 value2 */
+    private static class Args {
+        private final java.util.Map<String, String> map = new java.util.HashMap<>();
+
+        static Args parse(String[] args, int fromIndex) {
+            Args result = new Args();
+            for (int i = fromIndex; i < args.length; i++) {
+                String a = args[i];
+                if (a.startsWith("--")) {
+                    String k = a.substring(2);
+                    String v = (i + 1 < args.length && !args[i + 1].startsWith("--")) ? args[++i] : "";
+                    result.map.put(k, v);
+                }
+            }
+            return result;
+        }
+
+        String get(String key) {
+            return map.get(key);
+        }
+
+        String getOrDefault(String key, String def) {
+            return map.getOrDefault(key, def);
+        }
+    }
+}

package/aws/pom.xml

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <groupId>com.example</groupId>
+    <artifactId>s3-bucket-parser</artifactId>
+    <version>1.0.0</version>
+    <packaging>jar</packaging>
+
+    <properties>
+        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.target>8</maven.compiler.target>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <aws.sdk.version>1.12.194</aws.sdk.version>
+    </properties>
+
+    <dependencies>
+        <!-- 只引入 S3 模块，而不是整个 aws-java-sdk，减小体积 -->
+        <dependency>
+            <groupId>com.amazonaws</groupId>
+            <artifactId>aws-java-sdk-s3</artifactId>
+            <version>${aws.sdk.version}</version>
+        </dependency>
+
+        <!-- 用于把读取到的 JSON 内容格式化打印（可选，非 JSON 数据不受影响） -->
+        <dependency>
+            <groupId>com.fasterxml.jackson.core</groupId>
+            <artifactId>jackson-databind</artifactId>
+            <version>2.13.2</version>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <!-- 打包成带所有依赖的可执行 jar，方便直接 java -jar 运行 -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.4.1</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <transformers>
+                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
+                                    <mainClass>com.example.s3tool.S3BucketExplorer</mainClass>
+                                </transformer>
+                            </transformers>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@templmf/temp-solf-lmf",
-  "version": "0.0.162",
+  "version": "0.0.164",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/env.example

@@ -1,13 +0,0 @@
-# opencode server 地址（所有用户共用同一个 server）
-OPENCODE_SERVER_URL=http://127.0.0.1:4096
-
-# 如果 opencode server 开启了 OPENCODE_SERVER_PASSWORD，这里填 Basic Auth 密码
-OPENCODE_SERVER_USERNAME=opencode
-OPENCODE_SERVER_PASSWORD=123
-
-# 本网关监听端口
-PORT=3000
-
-# 给 cookie 签名用的随机字符串，生产环境务必替换
-COOKIE_SECRET=test
-DEBUG_EVENTS=1