@limecloud/agent-app-studio 0.1.0

package/src/core/config.mjs

@@ -0,0 +1,44 @@
+// input: 环境变量、本机配置文件与 CLI 显式参数
+// output: Studio API base、tenantId 与 token
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+
+const defaultConfigDir = join(homedir(), ".lime", "agent-app-studio");
+const defaultConfigPath = join(defaultConfigDir, "config.json");
+
+export function resolveApiBase(options = {}) {
+  return trimTrailingSlash(
+    options.apiBase || process.env.LIMECORE_API_BASE_URL || "https://api.limecloud.run/api"
+  );
+}
+
+export async function loadStudioConfig() {
+  try {
+    return JSON.parse(await readFile(defaultConfigPath, "utf8"));
+  } catch (error) {
+    return {};
+  }
+}
+
+export async function saveStudioConfig(nextConfig) {
+  const current = await loadStudioConfig();
+  const merged = { ...current, ...nextConfig };
+  await mkdir(defaultConfigDir, { recursive: true });
+  await writeFile(defaultConfigPath, `${JSON.stringify(merged, null, 2)}\n`);
+  return merged;
+}
+
+export async function resolveAuthContext(options = {}) {
+  const config = await loadStudioConfig();
+  return {
+    apiBase: resolveApiBase(options.apiBase ? options : config),
+    tenantId: options.tenantId || process.env.LIMECORE_TENANT_ID || config.tenantId || "",
+    token: options.token || process.env.LIME_AGENT_APP_STUDIO_TOKEN || config.token || "",
+  };
+}
+
+function trimTrailingSlash(value) {
+  return String(value || "").replace(/\/+$/, "");
+}

package/src/core/packager.mjs

@@ -0,0 +1,107 @@
+// input: 本地 Agent App 目录与输出目录
+// output: .lapp 安装包、sha256 与 manifest hash
+
+import { createHash } from "node:crypto";
+import { createReadStream, createWriteStream } from "node:fs";
+import { mkdir, readdir, readFile, stat } from "node:fs/promises";
+import { basename, join, relative, resolve } from "node:path";
+import yazl from "yazl";
+import { inspectProject } from "./project.mjs";
+
+const defaultExcludes = new Set([
+  ".git",
+  "node_modules",
+  ".DS_Store",
+  ".lime",
+  ".local",
+  "coverage",
+]);
+
+export async function packageProject(options = {}) {
+  const appDir = resolve(options.appDir || ".");
+  const inspection = await inspectProject(appDir);
+  if (!inspection.publishable) {
+    throw new Error(`项目不可发布：${inspection.issues.join("；")}`);
+  }
+  const outDir = resolve(options.outDir || join(appDir, "dist-package"));
+  await mkdir(outDir, { recursive: true });
+  const packageName = `${inspection.appId}-${inspection.version}.lapp`;
+  const packagePath = join(outDir, packageName);
+  const files = await collectPackageFiles(appDir);
+  await writeZip(appDir, files, packagePath);
+
+  const packageHash = await sha256File(packagePath);
+  const manifestPath = await resolveManifestPath(appDir);
+  const manifestHash = manifestPath ? await sha256File(manifestPath) : "";
+  return {
+    ...inspection,
+    packagePath,
+    packageName,
+    packageHash,
+    manifestHash,
+    sizeBytes: (await stat(packagePath)).size,
+    fileCount: files.length,
+  };
+}
+
+export async function collectPackageFiles(appDir) {
+  const root = resolve(appDir);
+  const result = [];
+  await walk(root, root, result);
+  result.sort((a, b) => a.localeCompare(b));
+  return result;
+}
+
+async function walk(root, current, result) {
+  const entries = await readdir(current, { withFileTypes: true });
+  for (const entry of entries) {
+    if (defaultExcludes.has(entry.name)) continue;
+    if (entry.name === "dist-package") continue;
+    const fullPath = join(current, entry.name);
+    const rel = relative(root, fullPath).replace(/\\/g, "/");
+    if (entry.isDirectory()) {
+      await walk(root, fullPath, result);
+      continue;
+    }
+    if (entry.isFile()) result.push(rel);
+  }
+}
+
+function writeZip(root, files, packagePath) {
+  return new Promise((resolvePromise, reject) => {
+    const zip = new yazl.ZipFile();
+    const output = createWriteStream(packagePath);
+    output.on("close", resolvePromise);
+    output.on("error", reject);
+    zip.outputStream.on("error", reject);
+    zip.outputStream.pipe(output);
+    for (const file of files) {
+      zip.addFile(join(root, file), file);
+    }
+    zip.end();
+  });
+}
+
+async function sha256File(path) {
+  return new Promise((resolvePromise, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(path);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolvePromise(`sha256:${hash.digest("hex")}`));
+  });
+}
+
+async function resolveManifestPath(appDir) {
+  const candidates = ["APP.md", "app.manifest.json", "app.manifest.yaml"];
+  for (const candidate of candidates) {
+    const target = join(appDir, candidate);
+    try {
+      await readFile(target);
+      return target;
+    } catch (error) {
+      // 继续尝试下一个标准清单文件。
+    }
+  }
+  return "";
+}

package/src/core/project.mjs

@@ -0,0 +1,106 @@
+// input: 本地 Agent App 目录
+// output: appId、版本、manifest、构建产物与发布前诊断
+
+import { access, readFile, stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
+
+export async function inspectProject(appDirInput = ".") {
+  const appDir = resolve(appDirInput);
+  const packageJson = await readOptionalJson(join(appDir, "package.json"));
+  const appMd = await readOptionalText(join(appDir, "APP.md"));
+  const capabilityYaml = await readOptionalText(join(appDir, "app.capabilities.yaml"));
+  const distStatus = await pathStatus(join(appDir, "dist"));
+  const distUiStatus = await pathStatus(join(appDir, "dist", "ui"));
+  const vendorStatus = await pathStatus(join(appDir, "dist", "ui", "vendor"));
+
+  const manifest = extractFrontmatter(appMd) || {};
+  const appId = firstString(
+    manifest.id,
+    manifest.appId,
+    manifest.name,
+    packageJson?.name
+  );
+  const version = firstString(manifest.version, packageJson?.version);
+  const manifestVersion = firstString(manifest.manifestVersion, manifest.standardVersion);
+  const issues = [];
+  const warnings = [];
+
+  if (!appMd) issues.push("缺少 APP.md");
+  if (!capabilityYaml) warnings.push("缺少 app.capabilities.yaml，云端入口可能不完整");
+  if (!appId) issues.push("无法识别 appId / name");
+  if (!version) issues.push("无法识别版本号");
+  if (!distStatus.exists) warnings.push("缺少 dist/，发布前通常需要先执行构建");
+  if (!distUiStatus.exists) warnings.push("缺少 dist/ui，UI App 可能无法运行");
+  if (distUiStatus.exists && !vendorStatus.exists) {
+    warnings.push("缺少 dist/ui/vendor；如果 UI import map 依赖 vendor，发布包会不可运行");
+  }
+
+  return {
+    appDir,
+    appId,
+    version,
+    manifestVersion,
+    packageName: packageJson?.name || "",
+    packageVersion: packageJson?.version || "",
+    hasBuildScript: Boolean(packageJson?.scripts?.build),
+    hasValidateScript: Boolean(packageJson?.scripts?.["validate:app"]),
+    files: {
+      appMd: Boolean(appMd),
+      capabilities: Boolean(capabilityYaml),
+      dist: distStatus.exists,
+      distUi: distUiStatus.exists,
+      vendor: vendorStatus.exists,
+    },
+    publishable: issues.length === 0,
+    issues,
+    warnings,
+  };
+}
+
+async function readOptionalText(path) {
+  try {
+    return await readFile(path, "utf8");
+  } catch (error) {
+    return "";
+  }
+}
+
+async function readOptionalJson(path) {
+  try {
+    return JSON.parse(await readFile(path, "utf8"));
+  } catch (error) {
+    return null;
+  }
+}
+
+async function pathStatus(path) {
+  try {
+    const item = await stat(path);
+    return { exists: true, directory: item.isDirectory(), file: item.isFile() };
+  } catch (error) {
+    return { exists: false, directory: false, file: false };
+  }
+}
+
+function extractFrontmatter(markdown) {
+  const match = String(markdown || "").match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return null;
+  const result = {};
+  for (const line of match[1].split(/\r?\n/)) {
+    const kv = line.match(/^([A-Za-z0-9_.-]+):\s*(.+?)\s*$/);
+    if (!kv) continue;
+    result[kv[1]] = kv[2].replace(/^['"]|['"]$/g, "");
+  }
+  return result;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    if (typeof value === "string" && value.trim()) return value.trim();
+  }
+  return "";
+}
+
+export async function ensureReadableAppDir(appDir) {
+  await access(resolve(appDir));
+}

package/src/core/publisher.mjs

@@ -0,0 +1,62 @@
+// input: 本地项目、认证上下文与发布参数
+// output: dry-run 计划或真实云端 release 结果
+
+import { packageProject } from "./packager.mjs";
+import { inspectProject } from "./project.mjs";
+import {
+  createDeveloperAgentAppRelease,
+  getDeveloperProfile,
+  uploadDeveloperAgentAppPackage,
+} from "./api.mjs";
+
+export async function buildPublishPlan(options = {}) {
+  const inspection = await inspectProject(options.appDir || ".");
+  const appId = options.appId || inspection.appId;
+  const channel = options.channel || "beta";
+  return {
+    appDir: inspection.appDir,
+    appId,
+    version: options.version || inspection.version,
+    manifestVersion: inspection.manifestVersion || "0.6.0",
+    channel,
+    publishable: inspection.publishable && Boolean(appId),
+    issues: inspection.issues,
+    warnings: inspection.warnings,
+    apiBase: options.apiBase,
+    tenantId: options.tenantId,
+  };
+}
+
+export async function publishProject(options = {}) {
+  const plan = await buildPublishPlan(options);
+  if (!plan.publishable) {
+    throw new Error(`发布计划不可执行：${plan.issues.join("；") || "缺少 appId"}`);
+  }
+  if (options.dryRun || !options.publish) {
+    return { mode: "dry-run", plan };
+  }
+  if (!options.token) throw new Error("缺少开发者 token，请先执行 auth login 或设置 LIME_AGENT_APP_STUDIO_TOKEN");
+  if (!options.tenantId) throw new Error("缺少 tenantId，请传入 --tenant-id 或设置 LIMECORE_TENANT_ID");
+
+  const profile = await getDeveloperProfile(options);
+  if (profile.status !== "approved") {
+    throw new Error(`当前账号未完成开发者认证：${profile.status}`);
+  }
+  const packaged = await packageProject({ appDir: options.appDir, outDir: options.outDir });
+  const upload = await uploadDeveloperAgentAppPackage({ ...options, appId: plan.appId, packagePath: packaged.packagePath });
+  const releasePayload = {
+    version: options.version || upload.version || packaged.version,
+    manifestVersion: upload.manifestVersion || packaged.manifestVersion || "0.6.0",
+    channel: plan.channel,
+    packageUrl: upload.packageUrl,
+    packageHash: upload.packageHash,
+    manifestHash: upload.manifestHash || packaged.manifestHash,
+    signatureRef: upload.signatureRef,
+    runtimeTargets: upload.runtimeTargets,
+    capabilityRequirements: upload.capabilityRequirements || {},
+    manifestSummary: upload.manifestSummary || {},
+    status: options.status || "ready",
+  };
+  const release = await createDeveloperAgentAppRelease({ ...options, appId: plan.appId, payload: releasePayload });
+  return { mode: "publish", plan, profile, packaged, upload, release };
+}

package/src/server.mjs

@@ -0,0 +1,70 @@
+// input: 本地 HTTP 请求
+// output: 可视化 Studio 工作台与发布 API
+
+import { createServer } from "node:http";
+import { readFile } from "node:fs/promises";
+import { extname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { inspectProject } from "./core/project.mjs";
+import { publishProject } from "./core/publisher.mjs";
+import { resolveAuthContext } from "./core/config.mjs";
+
+const root = fileURLToPath(new URL("..", import.meta.url));
+const appRoot = join(root, "app");
+
+export async function startStudioServer(options = {}) {
+  const port = Number(options.port || 4177);
+  const server = createServer(async (req, res) => {
+    try {
+      if (req.method === "POST" && req.url === "/api/inspect") {
+        const body = await readJson(req);
+        return sendJson(res, await inspectProject(body.appDir || "."));
+      }
+      if (req.method === "POST" && req.url === "/api/publish") {
+        const body = await readJson(req);
+        const auth = await resolveAuthContext(body);
+        return sendJson(res, await publishProject({ ...body, ...auth }));
+      }
+      return serveStatic(req, res);
+    } catch (error) {
+      return sendJson(res, { error: error?.message || String(error) }, 500);
+    }
+  });
+  await new Promise((resolve) => server.listen(port, resolve));
+  return { server, url: `http://127.0.0.1:${port}` };
+}
+
+async function serveStatic(req, res) {
+  const pathname = req.url === "/" ? "/index.html" : req.url.split("?")[0];
+  const safePath = pathname.replace(/\.\./g, "");
+  const filePath = join(appRoot, safePath);
+  const content = await readFile(filePath);
+  const type = contentType(filePath);
+  res.writeHead(200, { "Content-Type": type });
+  res.end(content);
+}
+
+async function readJson(req) {
+  const chunks = [];
+  for await (const chunk of req) chunks.push(chunk);
+  if (chunks.length === 0) return {};
+  return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+}
+
+function sendJson(res, payload, status = 200) {
+  res.writeHead(status, { "Content-Type": "application/json" });
+  res.end(JSON.stringify(payload, null, 2));
+}
+
+function contentType(path) {
+  switch (extname(path)) {
+    case ".js":
+      return "text/javascript; charset=utf-8";
+    case ".css":
+      return "text/css; charset=utf-8";
+    case ".html":
+      return "text/html; charset=utf-8";
+    default:
+      return "application/octet-stream";
+  }
+}