seacloud-sdk 0.9.8 → 0.10.0

package/dist/cli.js

@@ -588,6 +588,73 @@ async function appSearch(params) {
     throw error;
   }
 }
+
+// src/api/scan.ts
+async function scan(params) {
+  if (!params.uri && !params.img_base64) {
+    throw new SeacloudError("\u5FC5\u987B\u63D0\u4F9B uri \u6216 img_base64 \u4E2D\u7684\u81F3\u5C11\u4E00\u4E2A\u53C2\u6570");
+  }
+  if (params.is_video === 1 && params.img_base64) {
+    throw new SeacloudError("\u89C6\u9891\u68C0\u6D4B\u4E0D\u652F\u6301 base64 \u8F93\u5165\uFF0C\u5FC5\u987B\u4F7F\u7528 uri \u53C2\u6570");
+  }
+  if (!params.risk_types || params.risk_types.length === 0) {
+    throw new SeacloudError("\u5FC5\u987B\u63D0\u4F9B\u81F3\u5C11\u4E00\u4E2A\u98CE\u9669\u7C7B\u578B");
+  }
+  const client = getClient();
+  const config = client.getConfig();
+  const url = `${config.baseUrl}/scan`;
+  const token = await getApiToken(config.apiKey);
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout);
+  try {
+    const response = await config.fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify(params),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new SeacloudError(
+        `HTTP ${response.status}: ${errorBody}`,
+        response.status,
+        errorBody
+      );
+    }
+    const responseData = await response.json();
+    let result;
+    if (responseData.success !== void 0 && responseData.data) {
+      result = responseData.data;
+    } else {
+      result = responseData;
+    }
+    if (!result.ok) {
+      throw new SeacloudError(
+        `\u5185\u5BB9\u5B89\u5168\u68C0\u6D4B\u4E1A\u52A1\u9519\u8BEF: ${result.error || "\u672A\u77E5\u9519\u8BEF"}`,
+        void 0,
+        result
+      );
+    }
+    return result;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof SeacloudError) {
+      throw error;
+    }
+    if (error.name === "AbortError") {
+      throw new SeacloudError(`Request timeout after ${config.timeout}ms`);
+    }
+    throw new SeacloudError(
+      `Request failed: ${error.message}`,
+      void 0,
+      error
+    );
+  }
+}
 var __filename$1 = fileURLToPath(import.meta.url);
 dirname(__filename$1);
 function showHelp() {
@@ -601,6 +668,8 @@ Commands:
   llm <prompt>         Chat with LLM models
   agent <prompt>       Chat with Fast Agent (supports image/video generation)
   app <subcommand>     App-related operations (search, generation)
+  scan <uri>           Content safety scan (image/video/audio)
+  status <task-id>     Query task status by task ID
   <model>              Test specific model generation
 
 App Subcommands:
@@ -626,11 +695,21 @@ App Generation Options:
   --template-id <id>   Template ID (required)
   --params <json>      Input parameters as JSON string (required)
 
+Scan Options:
+  --risk-types <types> Risk types (default: POLITY,EROTIC,VIOLENT,CHILD)
+  --detected-age       Enable age detection (default: false)
+  --api-key <key>      API key (or set API_SERVICE_TOKEN env var)
+  --base-url <url>     Base URL (default: http://proxy.sg.seaverse.dev)
+
 Model Generation Options:
   --api-key <key>      API key (or set API_SERVICE_TOKEN env var)
   --base-url <url>     Base URL (default: http://proxy.sg.seaverse.dev)
   --params <json>      JSON parameters for the model
 
+Status Query Options:
+  --api-key <key>      API key (or set API_SERVICE_TOKEN env var)
+  --base-url <url>     Base URL (default: http://proxy.sg.seaverse.dev)
+
 Examples:
   # Chat with LLM (non-streaming)
   seacloud llm "What is the capital of France?"
@@ -654,6 +733,18 @@ Examples:
   # Create generation task (app generation)
   seacloud app generation --template-id "d26trpte878eqsnm3bjg" --params '[{"field":"prompt1","value":"hello"}]'
 
+  # Query task status
+  seacloud status d123456789abcdef
+
+  # Scan image
+  seacloud scan "https://example.com/image.jpg"
+
+  # Scan video with custom risk types
+  seacloud scan "https://example.com/video.mp4" --risk-types EROTIC,VIOLENT
+
+  # Scan with age detection
+  seacloud scan "https://example.com/photo.jpg" --detected-age
+
   # Test model generation
   seacloud flux_1_1_pro --params '{"prompt":"a beautiful sunset"}'
 
@@ -952,6 +1043,167 @@ async function runAppSearch(templateIdsStr, args) {
   });
   console.log(JSON.stringify(result, null, 2));
 }
+function detectMediaType(uri) {
+  const videoExtRegex = /\.(?:mp4|avi|mkv|mov|flv|wmv|webm|m4v|3gp|ts|mts|mpeg|mpg|vob|ogv|m2ts|divx|rm|rmvb|asf|f4v)(?:[^a-z0-9]|$)/i;
+  const audioExtRegex = /\.(?:mp3|wav|ogg|m4a|aac|flac|wma|m4b|m4p|m4r)(?:[^a-z0-9]|$)/i;
+  if (videoExtRegex.test(uri)) {
+    return { isVideo: 1, mediaType: "video" };
+  }
+  if (audioExtRegex.test(uri)) {
+    return { isVideo: 1, mediaType: "audio" };
+  }
+  return { isVideo: 0, mediaType: "image" };
+}
+async function runScan(uri, args) {
+  const options = {
+    riskTypes: ["POLITY", "EROTIC", "VIOLENT", "CHILD"],
+    detectedAge: false
+  };
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--risk-types") {
+      options.riskTypes = args[++i].split(",").map((t) => t.trim());
+    } else if (arg === "--detected-age") {
+      options.detectedAge = true;
+    } else if (arg === "--api-key") {
+      options.apiKey = args[++i];
+    } else if (arg === "--base-url") {
+      options.baseUrl = args[++i];
+    }
+  }
+  const apiKey = options.apiKey || process.env.API_SERVICE_TOKEN || "";
+  const baseUrl = options.baseUrl || process.env.SEACLOUD_BASE_URL || "http://proxy.sg.seaverse.dev";
+  initSeacloud(apiKey, { baseUrl });
+  const { isVideo, mediaType } = detectMediaType(uri);
+  console.log(`\u8D44\u6E90\u5730\u5740: ${uri}`);
+  console.log(`\u5A92\u4F53\u7C7B\u578B: ${mediaType}`);
+  console.log(`\u98CE\u9669\u7C7B\u578B: ${options.riskTypes.join(", ")}`);
+  console.log(`\u5E74\u9F84\u68C0\u6D4B: ${options.detectedAge ? "\u542F\u7528" : "\u7981\u7528"}`);
+  console.log("");
+  try {
+    const result = await scan({
+      uri,
+      risk_types: options.riskTypes,
+      detected_age: options.detectedAge ? 1 : 0,
+      is_video: isVideo
+    });
+    console.log("\u2705 \u626B\u63CF\u5B8C\u6210!\n");
+    console.log(`\u8BF7\u6C42\u72B6\u6001: ${result.ok ? "\u6210\u529F" : "\u5931\u8D25"}`);
+    if (result.nsfw_level !== void 0) {
+      console.log(`\u98CE\u9669\u7EA7\u522B: ${result.nsfw_level} (0-6)`);
+    }
+    if (result.risk_types && result.risk_types.length > 0) {
+      console.log(`\u68C0\u6D4B\u5230\u7684\u98CE\u9669\u7C7B\u578B: ${result.risk_types.join(", ")}`);
+    }
+    if (result.age_group && result.age_group.length > 0) {
+      console.log(`\u5E74\u9F84\u7EC4: ${JSON.stringify(result.age_group)}`);
+    }
+    if (isVideo === 1) {
+      if (result.video_duration !== void 0) {
+        console.log(`\u89C6\u9891\u65F6\u957F: ${result.video_duration} \u79D2`);
+      }
+      if (result.frame_count !== void 0) {
+        console.log(`\u603B\u62BD\u5E27\u6570: ${result.frame_count}`);
+      }
+      if (result.frames_checked !== void 0) {
+        console.log(`\u5B9E\u9645\u68C0\u6D4B\u5E27\u6570: ${result.frames_checked}`);
+      }
+      if (result.max_risk_frame !== void 0) {
+        console.log(`\u6700\u9AD8\u98CE\u9669\u5E27\u7D22\u5F15: ${result.max_risk_frame}`);
+      }
+      if (result.early_exit !== void 0) {
+        console.log(`\u63D0\u524D\u9000\u51FA: ${result.early_exit ? "\u662F" : "\u5426"}`);
+      }
+    }
+    if (result.label_items && result.label_items.length > 0) {
+      console.log(`
+\u68C0\u6D4B\u5230\u7684\u6807\u7B7E (${result.label_items.length} \u4E2A):`);
+      result.label_items.forEach((item, i) => {
+        console.log(`  ${i + 1}. ${item.name}`);
+        console.log(`     \u98CE\u9669\u7EA7\u522B: ${item.score}, \u7C7B\u578B: ${item.risk_type}`);
+      });
+    }
+    if (result.frame_results && result.frame_results.length > 0) {
+      console.log(`
+\u5E27\u68C0\u6D4B\u7ED3\u679C (\u524D5\u5E27):`);
+      result.frame_results.slice(0, 5).forEach((frame) => {
+        console.log(`  \u5E27 ${frame.frame_index}: \u98CE\u9669\u7EA7\u522B ${frame.nsfw_level}, \u6807\u7B7E\u6570 ${frame.label_items.length}`);
+      });
+      if (result.frame_results.length > 5) {
+        console.log(`  ... \u8FD8\u6709 ${result.frame_results.length - 5} \u5E27\u7ED3\u679C`);
+      }
+    }
+    if (result.error) {
+      console.log(`
+\u274C \u9519\u8BEF: ${result.error}`);
+    }
+  } catch (error) {
+    console.error("\n\u274C \u626B\u63CF\u5931\u8D25:", error.message);
+    process.exit(1);
+  }
+}
+async function runTaskStatus(taskId, args) {
+  const options = {};
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--api-key") options.apiKey = args[++i];
+    else if (arg === "--base-url") options.baseUrl = args[++i];
+  }
+  const apiKey = options.apiKey || process.env.API_SERVICE_TOKEN || "";
+  const baseUrl = options.baseUrl || process.env.SEACLOUD_BASE_URL || "http://proxy.sg.seaverse.dev";
+  const client = new SeacloudClient({ apiKey, baseUrl });
+  console.log(`Querying task status...`);
+  console.log(`Task ID: ${taskId}`);
+  console.log(`Base URL: ${baseUrl}
+`);
+  try {
+    const result = await client.getTaskStatus("/model/v1/generation", taskId);
+    console.log(`Status: ${result.status}`);
+    console.log(`Task ID: ${result.id}
+`);
+    if (result.status === "completed") {
+      console.log("\u2705 Task completed successfully!\n");
+      console.log("Output:");
+      console.log(JSON.stringify(result.output, null, 2));
+      if (result.output) {
+        const urls = [];
+        for (const item of result.output) {
+          if (item.content) {
+            for (const resource of item.content) {
+              if (resource.url) {
+                urls.push(resource.url);
+              }
+            }
+          }
+        }
+        if (urls.length > 0) {
+          console.log("\nGenerated URLs:");
+          urls.forEach((url, i) => {
+            console.log(`  ${i + 1}. ${url}`);
+          });
+        }
+      }
+    } else if (result.status === "failed") {
+      console.log("\u274C Task failed!\n");
+      console.log("Error:", JSON.stringify(result.error, null, 2));
+    } else if (result.status === "processing") {
+      console.log("\u23F3 Task is still processing...");
+      console.log("Please check again later.");
+    } else if (result.status === "pending") {
+      console.log("\u23F3 Task is pending...");
+      console.log("Please check again later.");
+    } else {
+      console.log("Full result:");
+      console.log(JSON.stringify(result, null, 2));
+    }
+  } catch (error) {
+    console.error("\nError querying task status:", error.message);
+    if (error.statusCode) {
+      console.error("HTTP Status Code:", error.statusCode);
+    }
+    process.exit(1);
+  }
+}
 async function main() {
   const args = process.argv.slice(2);
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
@@ -974,6 +1226,20 @@ async function main() {
         process.exit(1);
       }
       await runAgent(args[1], args.slice(2));
+    } else if (command === "scan") {
+      if (args.length < 2) {
+        console.error("Error: URI required for scan command");
+        console.log('Usage: seacloud scan "<uri>" [options]');
+        process.exit(1);
+      }
+      await runScan(args[1], args.slice(2));
+    } else if (command === "status") {
+      if (args.length < 2) {
+        console.error("Error: task ID required for status command");
+        console.log("Usage: seacloud status <task-id> [options]");
+        process.exit(1);
+      }
+      await runTaskStatus(args[1], args.slice(2));
     } else if (command === "app") {
       const subcommand = args[1];
       if (!subcommand) {