@dainprotocol/cli 1.2.36 → 1.3.0

package/dist/utils.js

@@ -1,164 +1,89 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
-    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_API_BASE_URL = exports.DEFAULT_PLATFORM_BASE_URL = exports.DEFAULT_TUNNEL_BASE_URL = void 0;
-exports.normalizeBaseUrl = normalizeBaseUrl;
-exports.joinUrl = joinUrl;
-exports.normalizeTunnelPublicUrl = normalizeTunnelPublicUrl;
-exports.parseEnvContent = parseEnvContent;
-exports.getDainConfig = getDainConfig;
-exports.displayTunnelUrl = displayTunnelUrl;
-exports.setupProxy = setupProxy;
-exports.logError = logError;
-exports.logSuccess = logSuccess;
-exports.logInfo = logInfo;
-exports.getStaticFilesPath = getStaticFilesPath;
-exports.extractOrgId = extractOrgId;
-exports.resolveOrgId = resolveOrgId;
-exports.fetchWithTimeout = fetchWithTimeout;
-exports.buildPlatformUrl = buildPlatformUrl;
-exports.validatePlatformConfig = validatePlatformConfig;
-exports.platformRequest = platformRequest;
-exports.createIdempotentCleanup = createIdempotentCleanup;
-var fs_1 = __importDefault(require("fs"));
-var path_1 = __importDefault(require("path"));
-var client_1 = require("@dainprotocol/tunnel/client");
-var ora_1 = __importDefault(require("ora"));
-var chalk_1 = __importDefault(require("chalk"));
-var dotenv_1 = __importDefault(require("dotenv"));
-exports.DEFAULT_TUNNEL_BASE_URL = "wss://tunnel.dain-local.com";
-exports.DEFAULT_PLATFORM_BASE_URL = "https://codegen-deploy-service.dainapp.com";
-exports.DEFAULT_API_BASE_URL = "https://dain-platform-ochre.vercel.app";
-function normalizeBaseUrl(value) {
-    var trimmed = value.trim();
+import fs from "fs";
+import path from "path";
+import { DainTunnel } from "@dainprotocol/tunnel/client";
+import ora from "ora";
+import chalk from "chalk";
+import dotenv from "dotenv";
+export const DEFAULT_TUNNEL_BASE_URL = "wss://tunnel.dain-local.com";
+export const DEFAULT_PLATFORM_BASE_URL = "https://codegen-deploy-service.dainapp.com";
+export const DEFAULT_API_BASE_URL = "https://dain-platform-ochre.vercel.app";
+export function normalizeBaseUrl(value) {
+    const trimmed = value.trim();
     if (!trimmed)
         return trimmed;
     try {
         return new URL(trimmed).toString().replace(/\/+$/, "");
     }
-    catch (_a) {
+    catch {
         return trimmed.replace(/\/+$/, "");
     }
 }
-function joinUrl(baseUrl, pathname) {
-    return "".concat(normalizeBaseUrl(baseUrl), "/").concat(pathname.replace(/^\/+/, ""));
+export function joinUrl(baseUrl, pathname) {
+    return `${normalizeBaseUrl(baseUrl)}/${pathname.replace(/^\/+/, "")}`;
 }
-function normalizeTunnelPublicUrl(tunnelUrl) {
-    var trimmed = tunnelUrl.trim();
+export function normalizeTunnelPublicUrl(tunnelUrl) {
+    const trimmed = tunnelUrl.trim();
     if (!trimmed)
         return trimmed;
     if (/^https?:\/\//i.test(trimmed))
         return normalizeBaseUrl(trimmed);
-    var likelyLocalhost = /^localhost[:/]|^127\./i.test(trimmed);
-    var protocol = likelyLocalhost ? "http://" : "https://";
-    return normalizeBaseUrl("".concat(protocol).concat(trimmed.replace(/^\/+/, "")));
+    const likelyLocalhost = /^localhost[:/]|^127\./i.test(trimmed);
+    const protocol = likelyLocalhost ? "http://" : "https://";
+    return normalizeBaseUrl(`${protocol}${trimmed.replace(/^\/+/, "")}`);
 }
-function parseEnvContent(envContent) {
-    return Object.entries(dotenv_1.default.parse(envContent))
-        .map(function (_a) {
-        var name = _a[0], value = _a[1];
-        return ({ name: name.trim(), value: value });
-    })
-        .filter(function (env) { return env.name !== "" && env.value !== ""; });
+export function parseEnvContent(envContent) {
+    return Object.entries(dotenv.parse(envContent))
+        .map(([name, value]) => ({ name: name.trim(), value }))
+        .filter((env) => env.name !== "" && env.value !== "");
 }
 function parseDainApiKey(apiKey) {
-    if (!(apiKey === null || apiKey === void 0 ? void 0 : apiKey.startsWith("sk_agent_")))
+    if (!apiKey?.startsWith("sk_agent_"))
         return null;
-    var parts = apiKey.split("_");
+    const parts = apiKey.split("_");
     if (parts.length < 5)
         return null;
-    var isOrgFormat = parts[2] === "org";
+    const isOrgFormat = parts[2] === "org";
     if (isOrgFormat) {
-        var orgId_1 = parts[3];
-        var isAgentKeyword = parts[4] === "agent";
-        var agentId_1 = parts[5];
-        var secret_1 = parts.slice(6).join("_");
-        if (!orgId_1 || !isAgentKeyword || !agentId_1 || !secret_1)
+        const orgId = parts[3];
+        const isAgentKeyword = parts[4] === "agent";
+        const agentId = parts[5];
+        const secret = parts.slice(6).join("_");
+        if (!orgId || !isAgentKeyword || !agentId || !secret)
             return null;
-        return { agentId: agentId_1, orgId: orgId_1, secret: secret_1 };
+        return { agentId, orgId, secret };
     }
-    var agentId = parts[2];
-    var orgId = parts[3];
-    var secret = parts.slice(4).join("_");
+    const agentId = parts[2];
+    const orgId = parts[3];
+    const secret = parts.slice(4).join("_");
     if (!agentId || !orgId || !secret)
         return null;
-    return { agentId: agentId, orgId: orgId, secret: secret };
+    return { agentId, orgId, secret };
 }
 function loadEnvFiles() {
-    var envFiles = [".env.local", ".env", ".env.development", ".env.production"];
-    for (var _i = 0, envFiles_1 = envFiles; _i < envFiles_1.length; _i++) {
-        var file = envFiles_1[_i];
-        var envPath = path_1.default.join(process.cwd(), file);
-        if (fs_1.default.existsSync(envPath)) {
-            dotenv_1.default.config({ path: envPath });
+    const envFiles = [".env.local", ".env", ".env.development", ".env.production"];
+    for (const file of envFiles) {
+        const envPath = path.join(process.cwd(), file);
+        if (fs.existsSync(envPath)) {
+            dotenv.config({ path: envPath });
         }
     }
 }
-function getDainConfig(configFile) {
+export function getDainConfig(configFile) {
     loadEnvFiles();
-    var configPath = path_1.default.join(process.cwd(), configFile || "dain.json");
-    if (!fs_1.default.existsSync(configPath)) {
-        logError("Configuration file not found: ".concat(configPath));
+    const configPath = path.join(process.cwd(), configFile || "dain.json");
+    if (!fs.existsSync(configPath)) {
+        logError(`Configuration file not found: ${configPath}`);
         process.exit(1);
     }
     try {
-        var config = JSON.parse(fs_1.default.readFileSync(configPath, "utf8"));
+        const config = JSON.parse(fs.readFileSync(configPath, "utf8"));
         if (!config["main-file"])
             throw new Error("Configuration must include 'main-file'");
-        config.environment || (config.environment = "development");
-        config.version || (config.version = "1.0.0");
-        config["out-dir"] || (config["out-dir"] = "dist");
-        config.runtime || (config.runtime = "node");
-        config["tunnel-base-url"] = normalizeBaseUrl(config["tunnel-base-url"] || exports.DEFAULT_TUNNEL_BASE_URL);
+        config.environment ||= "development";
+        config.version ||= "1.0.0";
+        config["out-dir"] ||= "dist";
+        config.runtime ||= "node";
+        config["tunnel-base-url"] = normalizeBaseUrl(config["tunnel-base-url"] || DEFAULT_TUNNEL_BASE_URL);
         if (config["platform-base-url"])
             config["platform-base-url"] = normalizeBaseUrl(config["platform-base-url"]);
         if (config["api-base-url"])
@@ -171,123 +96,106 @@ function getDainConfig(configFile) {
         return config;
     }
     catch (error) {
-        throw new Error("Error reading or parsing configuration file: ".concat(error));
+        throw new Error(`Error reading or parsing configuration file: ${error}`);
     }
 }
-function displayTunnelUrl(tunnelUrl) {
-    console.log("\n".concat(chalk_1.default.green("------------------------------------------------------------"), "\n").concat(chalk_1.default.green("Your service is available publicly at:"), "\n").concat(chalk_1.default.cyan.underline(tunnelUrl), "\n\n").concat(chalk_1.default.yellow("This service URL can be connected to by a DAIN client or assistant"), "\n").concat(chalk_1.default.yellow("(such as butterfly in development mode)"), "\n\n").concat(chalk_1.default.red("You should not visit this URL directly"), "\n").concat(chalk_1.default.green("------------------------------------------------------------"), "\n"));
-}
-function setupProxy(port, apiKey, config) {
-    return __awaiter(this, void 0, void 0, function () {
-        var spinner, client_2, tunnelUrl, _a, error_1;
-        return __generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    spinner = (0, ora_1.default)("Setting up proxy...").start();
-                    _b.label = 1;
-                case 1:
-                    _b.trys.push([1, 3, , 4]);
-                    client_2 = new client_1.DainTunnel(config["tunnel-base-url"] || exports.DEFAULT_TUNNEL_BASE_URL, apiKey);
-                    // Handle tunnel lifecycle events
-                    client_2.on("disconnected", function () {
-                        console.log(chalk_1.default.yellow("\n⚠ Tunnel disconnected. Attempting to reconnect..."));
-                    });
-                    client_2.on("reconnecting", function (_a) {
-                        var attempt = _a.attempt, delay = _a.delay;
-                        console.log(chalk_1.default.yellow("  Reconnection attempt ".concat(attempt, "/10 in ").concat(Math.round(delay / 1000), "s...")));
-                    });
-                    client_2.on("reconnected", function () {
-                        console.log(chalk_1.default.green("✓ Tunnel reconnected successfully"));
-                    });
-                    client_2.on("error", function (error) {
-                        console.error(chalk_1.default.red("\n\u2717 Tunnel error: ".concat(error.message)));
-                    });
-                    client_2.on("max_reconnect_attempts", function () {
-                        console.error(chalk_1.default.red("\n✗ Tunnel failed to reconnect after 10 attempts."));
-                        console.log(chalk_1.default.yellow("  Resetting and trying again..."));
-                        // Reset and try one more time (resetReconnection added in tunnel 1.1.31)
-                        if (typeof client_2.resetReconnection === "function") {
-                            client_2.resetReconnection();
-                            client_2.start(parseInt(port)).catch(function (err) {
-                                console.error(chalk_1.default.red("\n\u2717 Unable to restore tunnel connection: ".concat(err.message)));
-                                console.log(chalk_1.default.yellow("  Please restart the dev server manually."));
-                            });
-                        }
-                        else {
-                            console.log(chalk_1.default.yellow("  Please restart the dev server manually."));
-                        }
-                    });
-                    _a = normalizeTunnelPublicUrl;
-                    return [4 /*yield*/, client_2.start(parseInt(port))];
-                case 2:
-                    tunnelUrl = _a.apply(void 0, [_b.sent()]);
-                    spinner.succeed("Proxy setup complete");
-                    return [2 /*return*/, { client: client_2, tunnelUrl: tunnelUrl }];
-                case 3:
-                    error_1 = _b.sent();
-                    spinner.fail(chalk_1.default.red("Error setting up proxy"));
-                    console.error(chalk_1.default.red(error_1));
-                    throw error_1;
-                case 4: return [2 /*return*/];
+export function displayTunnelUrl(tunnelUrl) {
+    console.log(`
+${chalk.green("------------------------------------------------------------")}
+${chalk.green("Your service is available publicly at:")}
+${chalk.cyan.underline(tunnelUrl)}
+
+${chalk.yellow("This service URL can be connected to by a DAIN client or assistant")}
+${chalk.yellow("(such as butterfly in development mode)")}
+
+${chalk.red("You should not visit this URL directly")}
+${chalk.green("------------------------------------------------------------")}
+`);
+}
+export async function setupProxy(port, apiKey, config) {
+    const spinner = ora("Setting up proxy...").start();
+    try {
+        const client = new DainTunnel(config["tunnel-base-url"] || DEFAULT_TUNNEL_BASE_URL, apiKey);
+        // Handle tunnel lifecycle events
+        client.on("disconnected", () => {
+            console.log(chalk.yellow("\n⚠ Tunnel disconnected. Attempting to reconnect..."));
+        });
+        client.on("reconnecting", ({ attempt, delay }) => {
+            console.log(chalk.yellow(`  Reconnection attempt ${attempt}/10 in ${Math.round(delay / 1000)}s...`));
+        });
+        client.on("reconnected", () => {
+            console.log(chalk.green("✓ Tunnel reconnected successfully"));
+        });
+        client.on("error", (error) => {
+            console.error(chalk.red(`\n✗ Tunnel error: ${error.message}`));
+        });
+        client.on("max_reconnect_attempts", () => {
+            console.error(chalk.red("\n✗ Tunnel failed to reconnect after 10 attempts."));
+            console.log(chalk.yellow("  Resetting and trying again..."));
+            // Reset and try one more time (resetReconnection added in tunnel 1.1.31)
+            if (typeof client.resetReconnection === "function") {
+                client.resetReconnection();
+                client.start(parseInt(port)).catch((err) => {
+                    console.error(chalk.red(`\n✗ Unable to restore tunnel connection: ${err.message}`));
+                    console.log(chalk.yellow("  Please restart the dev server manually."));
+                });
+            }
+            else {
+                console.log(chalk.yellow("  Please restart the dev server manually."));
             }
         });
-    });
+        const tunnelUrl = normalizeTunnelPublicUrl(await client.start(parseInt(port)));
+        spinner.succeed("Proxy setup complete");
+        return { client, tunnelUrl };
+    }
+    catch (error) {
+        spinner.fail(chalk.red("Error setting up proxy"));
+        console.error(chalk.red(error));
+        throw error;
+    }
 }
-function logError(message, error) {
-    console.error(chalk_1.default.red("\nError: ".concat(message)));
+export function logError(message, error) {
+    console.error(chalk.red(`\nError: ${message}`));
     if (error)
-        console.error(chalk_1.default.red(error));
+        console.error(chalk.red(error));
 }
-function logSuccess(message) {
-    console.log(chalk_1.default.green("\nSuccess: ".concat(message)));
+export function logSuccess(message) {
+    console.log(chalk.green(`\nSuccess: ${message}`));
 }
-function logInfo(message) {
-    console.log(chalk_1.default.blue("\nInfo: ".concat(message)));
+export function logInfo(message) {
+    console.log(chalk.blue(`\nInfo: ${message}`));
 }
-function getStaticFilesPath() {
-    return path_1.default.join(process.cwd(), "static");
+export function getStaticFilesPath() {
+    return path.join(process.cwd(), "static");
 }
-function extractOrgId(apiKey) {
-    var _a;
-    return ((_a = parseDainApiKey(apiKey)) === null || _a === void 0 ? void 0 : _a.orgId) || "";
+export function extractOrgId(apiKey) {
+    return parseDainApiKey(apiKey)?.orgId || "";
 }
-function resolveOrgId(config) {
+export function resolveOrgId(config) {
     return config["org-id"] || process.env.DAIN_ORG_ID || extractOrgId(config["api-key"]);
 }
-function fetchWithTimeout(url_1, options_1) {
-    return __awaiter(this, arguments, void 0, function (url, options, timeoutMs) {
-        var controller, timeoutId;
-        if (timeoutMs === void 0) { timeoutMs = 30000; }
-        return __generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    controller = new AbortController();
-                    timeoutId = setTimeout(function () { return controller.abort(); }, timeoutMs);
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, , 3, 4]);
-                    return [4 /*yield*/, fetch(url, __assign(__assign({}, options), { signal: controller.signal }))];
-                case 2: return [2 /*return*/, _a.sent()];
-                case 3:
-                    clearTimeout(timeoutId);
-                    return [7 /*endfinally*/];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
-}
-function buildPlatformUrl(config, orgId, endpoint, overrides) {
-    var baseUrl = config["platform-base-url"] || exports.DEFAULT_PLATFORM_BASE_URL;
-    var deploymentId = (overrides === null || overrides === void 0 ? void 0 : overrides.deploymentId) || config["deployment-id"];
-    var environment = (overrides === null || overrides === void 0 ? void 0 : overrides.environment) || config["environment"];
-    var serviceId = (overrides === null || overrides === void 0 ? void 0 : overrides.serviceId) || config["service-id"];
-    return joinUrl(baseUrl, "/codegen-deploy/".concat(endpoint, "/").concat(orgId, "/").concat(serviceId, "/").concat(deploymentId, "/").concat(environment));
+export async function fetchWithTimeout(url, options, timeoutMs = 30000) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
 }
-function validatePlatformConfig(config, overrides) {
-    var orgId = resolveOrgId(config);
-    var apiKey = config["api-key"];
-    var deploymentId = (overrides === null || overrides === void 0 ? void 0 : overrides.deploymentId) || config["deployment-id"];
-    var serviceId = (overrides === null || overrides === void 0 ? void 0 : overrides.serviceId) || config["service-id"];
+export function buildPlatformUrl(config, orgId, endpoint, overrides) {
+    const baseUrl = config["platform-base-url"] || DEFAULT_PLATFORM_BASE_URL;
+    const deploymentId = overrides?.deploymentId || config["deployment-id"];
+    const environment = overrides?.environment || config["environment"];
+    const serviceId = overrides?.serviceId || config["service-id"];
+    return joinUrl(baseUrl, `/codegen-deploy/${endpoint}/${orgId}/${serviceId}/${deploymentId}/${environment}`);
+}
+export function validatePlatformConfig(config, overrides) {
+    const orgId = resolveOrgId(config);
+    const apiKey = config["api-key"];
+    const deploymentId = overrides?.deploymentId || config["deployment-id"];
+    const serviceId = overrides?.serviceId || config["service-id"];
     if (!orgId) {
         logError("Org ID not found. Ensure your API key or DAIN_ORG_ID is set.");
         process.exit(1);
@@ -300,27 +208,21 @@ function validatePlatformConfig(config, overrides) {
         logError("API key not found");
         process.exit(1);
     }
-    return { config: config, orgId: orgId, apiKey: apiKey, deploymentId: deploymentId, serviceId: serviceId };
+    return { config, orgId, apiKey, deploymentId, serviceId };
 }
-function platformRequest(ctx_1, endpoint_1) {
-    return __awaiter(this, arguments, void 0, function (ctx, endpoint, method, overrides) {
-        var url;
-        if (method === void 0) { method = "GET"; }
-        return __generator(this, function (_a) {
-            url = buildPlatformUrl(ctx.config, ctx.orgId, endpoint, {
-                deploymentId: ctx.deploymentId,
-                serviceId: ctx.serviceId,
-                environment: overrides === null || overrides === void 0 ? void 0 : overrides.environment,
-            });
-            return [2 /*return*/, fetchWithTimeout(url, {
-                    method: method,
-                    headers: { "Content-Type": "application/json", Authorization: "Bearer ".concat(ctx.apiKey) },
-                })];
-        });
+export async function platformRequest(ctx, endpoint, method = "GET", overrides) {
+    const url = buildPlatformUrl(ctx.config, ctx.orgId, endpoint, {
+        deploymentId: ctx.deploymentId,
+        serviceId: ctx.serviceId,
+        environment: overrides?.environment,
+    });
+    return fetchWithTimeout(url, {
+        method,
+        headers: { "Content-Type": "application/json", Authorization: `Bearer ${ctx.apiKey}` },
     });
 }
-function createIdempotentCleanup(cleanupFn) {
-    var hasRun = false;
+export function createIdempotentCleanup(cleanupFn) {
+    let hasRun = false;
     return function idempotentCleanup() {
         if (hasRun)
             return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dainprotocol/cli",
-  "version": "1.2.36",
+  "version": "1.3.0",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -23,8 +23,8 @@
   ],
   "dependencies": {
     "@ai-sdk/anthropic": "^0.0.50",
-    "@dainprotocol/service-sdk": "2.0.82",
-    "@dainprotocol/tunnel": "1.1.35",
+    "@dainprotocol/service-sdk": "2.0.88",
+    "@dainprotocol/tunnel": "2.0.0",
     "@types/fs-extra": "^11.0.4",
     "@types/localtunnel": "^2.0.4",
     "ai": "^3.3.41",