@stacksjs/actions 0.70.160 → 0.70.162

package/README.md

@@ -9,7 +9,7 @@ This package contains the Stacks Actions.
 - Generate Stacks Library Entry Points
 - Generate Package Manifests
 - Generate VS Code Custom Data file
-- Generate Vue 2 Compatibility (maybe deprecate)
+- Generate STX component metadata
 
 ## 🤖 Usage
 

package/dist/blog.js

@@ -208,7 +208,7 @@ async function blogConfig(bp, fm) {
     title: fm.title || cfg.title,
     description: fm.description || cfg.description,
     docsDir: CONTENT_DIR,
-    theme: "vitepress",
+    theme: "bun",
     markdown: { ...bp.defaultConfig.markdown, css: `${baseCss}
 ${themeCss}` },
     themeConfig: {

package/dist/build/desktop.js

@@ -1,5 +1,59 @@
-import { runCommand } from "@stacksjs/cli";
-import { corePath } from "@stacksjs/path";
-await runCommand("bun run build:app", {
-  cwd: corePath("desktop")
+import { createHash } from "node:crypto";
+import { chmodSync, copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+import process from "node:process";
+import { log, runCommand } from "@stacksjs/cli";
+import { corePath, projectPath, storagePath } from "@stacksjs/path";
+import { assertDesktopReleaseChannel, resolveCraftBinary } from "@stacksjs/desktop";
+const outputDir = storagePath("framework/desktop-dist"), launcherName = process.platform === "win32" ? "stacks-desktop.exe" : "stacks-desktop", runtimeName = process.platform === "win32" ? "craft-runtime.exe" : "craft-runtime", appUrl = process.env.DESKTOP_URL || process.env.APP_URL, releaseChannel = process.env.DESKTOP_RELEASE_CHANNEL === "stable" ? "stable" : "experimental", support = assertDesktopReleaseChannel(releaseChannel);
+if (!appUrl)
+  throw Error("Desktop builds require APP_URL or DESKTOP_URL so the native app knows which Stacks application to open");
+const url = new URL(/^https?:\/\//.test(appUrl) ? appUrl : `https://${appUrl}`), craftBinary = resolveCraftBinary();
+if (basename(craftBinary) === "craft" && !existsSync(craftBinary))
+  throw Error("Build Craft first in ~/Code/Tools/craft, or set CRAFT_BIN to the native Craft binary");
+if (existsSync(outputDir))
+  rmSync(outputDir, { recursive: !0 });
+mkdirSync(outputDir, { recursive: !0 });
+await runCommand("bun run build", { cwd: corePath("desktop") });
+await runCommand(`bun build --compile ${JSON.stringify(corePath("desktop/src/launcher.ts"))} --outfile ${JSON.stringify(join(outputDir, launcherName))}`, {
+  cwd: projectPath()
 });
+copyFileSync(craftBinary, join(outputDir, runtimeName));
+if (process.platform !== "win32") {
+  chmodSync(join(outputDir, launcherName), 493);
+  chmodSync(join(outputDir, runtimeName), 493);
+}
+writeFileSync(join(outputDir, "desktop.json"), `${JSON.stringify({
+  url: url.toString().replace(/\/$/, ""),
+  title: process.env.APP_NAME || "Stacks",
+  width: 1400,
+  height: 900,
+  darkMode: !1,
+  systemTray: !0,
+  hideDockIcon: !1,
+  releaseChannel,
+  platform: process.platform,
+  architecture: process.arch
+}, null, 2)}
+`);
+const gitResult = Bun.spawnSync(["git", "rev-parse", "HEAD"], { cwd: projectPath() });
+if (gitResult.exitCode !== 0)
+  throw Error("Desktop builds require an exact Git source revision");
+const sourceRevision = gitResult.stdout.toString().trim(), artifacts = [launcherName, runtimeName, "desktop.json"].map((name) => {
+  const contents = readFileSync(join(outputDir, name));
+  return { name, bytes: contents.byteLength, sha256: createHash("sha256").update(contents).digest("hex") };
+});
+writeFileSync(join(outputDir, "provenance.json"), `${JSON.stringify({
+  schemaVersion: "1.0.0",
+  sourceRepository: "https://github.com/stacksjs/stacks",
+  sourceRevision,
+  builtWith: { bun: Bun.version, craftSha256: artifacts.find((artifact) => artifact.name === runtimeName)?.sha256 },
+  target: { platform: process.platform, architecture: process.arch, status: support.status, osVersions: support.osVersions },
+  releaseChannel,
+  artifacts
+}, null, 2)}
+`);
+writeFileSync(join(outputDir, "checksums.sha256"), `${artifacts.map((artifact) => `${artifact.sha256}  ${artifact.name}`).join(`
+`)}
+`);
+log.success(`Built Craft desktop application in ${outputDir}`);

package/dist/build/views.js

@@ -1,11 +1,16 @@
 import { runCommand } from "@stacksjs/cli";
-import { frameworkPath, projectPath } from "@stacksjs/path";
+import { projectPath } from "@stacksjs/path";
 const projectBuild = projectPath("build.ts");
-if (await Bun.file(projectBuild).exists())
-  await runCommand("bun build.ts", {
+if (await Bun.file(projectBuild).exists()) {
+  const result = await runCommand("bun build.ts", {
     cwd: projectPath()
   });
-else
-  await runCommand("bun run build", {
-    cwd: frameworkPath("views/web")
+  if (result.isErr)
+    throw result.error;
+} else {
+  const result = await runCommand("bunx --bun @stacksjs/stx build --pages resources/views --out dist", {
+    cwd: projectPath()
   });
+  if (result.isErr)
+    throw result.error;
+}

package/dist/build.d.ts

@@ -2,7 +2,7 @@ import type { BuildOptions } from '@stacksjs/types';
 export declare function invoke(options: BuildOptions): Promise<void>;
 export declare function build(options: BuildOptions): Promise<void>;
 export declare function componentLibraries(options: BuildOptions): Promise<void>;
-export declare function vueComponentLibrary(options: BuildOptions): Promise<void>;
+export declare function stxComponentLibrary(options: BuildOptions): Promise<void>;
 export declare function webComponentLibrary(options: BuildOptions): Promise<void>;
 export declare function docs(options: BuildOptions): Promise<void>;
 export declare function stacks(options: BuildOptions): Promise<void>;

package/dist/build.js

@@ -21,10 +21,10 @@ export async function build(options) {
 }
 export async function componentLibraries(options) {
   await runNpmScript(NpmScript.GenerateEntries, options);
-  await vueComponentLibrary(options);
+  await stxComponentLibrary(options);
   await webComponentLibrary(options);
 }
-export async function vueComponentLibrary(options) {
+export async function stxComponentLibrary(options) {
   if (hasComponents()) {
     log.info("Building your component library...");
     await runNpmScript(NpmScript.BuildComponents, options);

package/dist/copy-types.js

@@ -1,7 +1,6 @@
 import { frameworkPath } from "@stacksjs/path";
 import { copyFolder } from "@stacksjs/storage";
 const destinations = [
-  [frameworkPath("dist/types/components"), frameworkPath("defaults/resources/components/vue/dist/types")],
   [frameworkPath("dist/types/components"), frameworkPath("defaults/resources/components/web/dist/types")],
   [frameworkPath("dist/types/functions"), frameworkPath("defaults/functions/dist/types")]
 ];

package/dist/dev/components.js

@@ -3,5 +3,5 @@ import { libsPath } from "@stacksjs/path";
 const options = parseOptions();
 await runCommand("bun run dev", {
   ...options,
-  cwd: libsPath("components/vue")
+  cwd: libsPath("components/stx")
 });

package/dist/dev/dashboard.js

@@ -316,14 +316,14 @@ const dashboardToggles = await loadDashboardToggles(), manifestPath = storagePat
 writeFileSync(manifestPath, JSON.stringify(manifestPayload, null, 2));
 const serverReady = await waitForServer(dashboardPort);
 restoreConsole();
-let proxyStarted = !1;
-startReverseProxy().then((ok) => {
-  proxyStarted = ok;
-}).catch((err) => {
-  if (verbose)
-    console.warn("[Dashboard] Reverse proxy failed:", err);
-});
-const dashboardHttpsUrl = dashboardDomain ? `https://${dashboardDomain}` : null, dashboardLocalUrl = `http://localhost:${dashboardPort}`, initialUrl = `http://localhost:${dashboardPort}/`, elapsedMs = (Bun.nanoseconds() - startTime) / 1e6;
+let proxyStarted = Boolean(process.env.STACKS_PROXY_MANAGED);
+if (!proxyStarted)
+  proxyStarted = await startReverseProxy().catch((err) => {
+    if (verbose)
+      console.warn("[Dashboard] Reverse proxy failed:", err);
+    return !1;
+  });
+const dashboardHttpsUrl = dashboardDomain ? `https://${dashboardDomain}` : null, dashboardLocalUrl = `http://localhost:${dashboardPort}`, initialUrl = dashboardHttpsUrl && proxyStarted ? `${dashboardHttpsUrl}/` : `${dashboardLocalUrl}/`, elapsedMs = (Bun.nanoseconds() - startTime) / 1e6;
 console.log();
 console.log(`  ${bold(cyan("stacks dashboard"))}`);
 console.log();

package/dist/dev/desktop.d.ts

@@ -1 +1 @@
-export {};
+

package/dist/dev/desktop.js

@@ -1,5 +1 @@
-import { runCommand } from "@stacksjs/cli";
-import { frameworkPath } from "@stacksjs/path";
-await runCommand("bun run dev", {
-  cwd: frameworkPath("views/desktop")
-});
+await import("./dashboard");

package/dist/dev/system-tray.js

@@ -1,5 +1,172 @@
-import { runCommand } from "@stacksjs/cli";
-import { frameworkPath } from "@stacksjs/path";
-await runCommand("bun run dev", {
-  cwd: frameworkPath("system-tray")
+import { homedir, networkInterfaces } from "node:os";
+import { basename, join } from "node:path";
+import process from "node:process";
+import { bold, cyan, dim, green } from "@stacksjs/cli";
+import { openDevWindow } from "@stacksjs/desktop";
+import { projectPath, storagePath } from "@stacksjs/path";
+import { findStacksProjects } from "@stacksjs/utils";
+import { findAvailablePort, waitForServer } from "./dashboard-utils";
+const preferredPort = Number(process.env.PORT_SYSTEM_TRAY) || 3009, port = await findAvailablePort(preferredPort), trayViews = storagePath("framework/defaults/views/system-tray"), appUrl = process.env.APP_URL || "stacks.test", domain = appUrl.replace(/^https?:\/\//, "").replace(/\/$/, ""), hasPrettyDomain = !domain.includes("localhost:") && domain !== "localhost", trayDomain = hasPrettyDomain ? `tray.${domain}` : null, localUrl = `http://localhost:${port}`;
+let cachedProjects;
+async function discoverProjects(refresh = !1) {
+  if (cachedProjects && !refresh)
+    return cachedProjects;
+  const discovered = await findStacksProjects(join(homedir(), "Code"), { quiet: !0 }).catch(() => []), candidates = [...new Set([projectPath(), ...discovered])];
+  cachedProjects = (await Promise.all(candidates.map(async (project) => ({
+    project,
+    valid: await Bun.file(join(project, "buddy")).exists()
+  })))).filter((check) => check.valid).map((check) => check.project).sort((a, b) => basename(a).localeCompare(basename(b)));
+  return cachedProjects;
+}
+async function runBuddy(project, args) {
+  const child = Bun.spawn([join(project, "buddy"), ...args, "--no-interaction"], {
+    cwd: project,
+    stdout: "pipe",
+    stderr: "pipe"
+  }), [stdout, stderr, exitCode] = await Promise.all([
+    new Response(child.stdout).text(),
+    new Response(child.stderr).text(),
+    child.exited
+  ]);
+  return { output: [stdout, stderr].filter(Boolean).join(`
+`).trim(), exitCode };
+}
+function openPath(path) {
+  const command = process.platform === "darwin" ? ["open", path] : process.platform === "win32" ? ["cmd", "/c", "start", "", path] : ["xdg-open", path];
+  Bun.spawn(command, { stdout: "ignore", stderr: "ignore" }).unref();
+}
+function openTerminal(project) {
+  const command = process.platform === "darwin" ? ["open", "-a", "Terminal", project] : process.platform === "win32" ? ["cmd", "/c", "start", "cmd", "/K", `cd /d ${project}`] : ["x-terminal-emulator", "--working-directory", project];
+  Bun.spawn(command, { stdout: "ignore", stderr: "ignore" }).unref();
+}
+function localIpAddress() {
+  for (const addresses of Object.values(networkInterfaces()))
+    for (const address of addresses || [])
+      if (address.family === "IPv4" && !address.internal)
+        return address.address;
+  return "127.0.0.1";
+}
+function dashboardUrl(path = "") {
+  return `${hasPrettyDomain ? `https://dashboard.${domain}` : `http://localhost:${Number(process.env.PORT_ADMIN) || 3002}`}${path}`;
+}
+async function handleAction(input) {
+  const projects = await discoverProjects(), project = input.project || projectPath();
+  if (!projects.includes(project))
+    return Response.json({ ok: !1, error: "Unknown Stacks project" }, { status: 400 });
+  switch (input.action) {
+    case "refresh":
+      return Response.json({ ok: !0, projects: await discoverProjects(!0) });
+    case "open-terminal":
+      openTerminal(project);
+      return Response.json({ ok: !0, message: `Opened Terminal in ${basename(project)}` });
+    case "env-check": {
+      const result = await runBuddy(project, ["doctor"]);
+      return Response.json({ ok: result.exitCode === 0, ...result });
+    }
+    case "settings":
+      openPath(dashboardUrl("/settings"));
+      return Response.json({ ok: !0, message: "Opened dashboard settings" });
+    case "check-updates": {
+      const result = await runBuddy(project, ["outdated"]);
+      return Response.json({ ok: result.exitCode === 0, ...result });
+    }
+    case "copy-ip":
+      return Response.json({ ok: !0, value: localIpAddress(), message: "IP address ready to copy" });
+    case "open-dashboard":
+      openPath(dashboardUrl());
+      return Response.json({ ok: !0, message: "Opened dashboard" });
+    case "buddy-commands": {
+      const result = await runBuddy(project, ["list"]);
+      return Response.json({ ok: result.exitCode === 0, ...result });
+    }
+    case "deploy": {
+      if (!input.confirmed)
+        return Response.json({ ok: !1, confirmationRequired: !0, error: "Deployment confirmation required" }, { status: 409 });
+      Bun.spawn([join(project, "buddy"), "deploy", "--no-interaction"], {
+        cwd: project,
+        stdout: "inherit",
+        stderr: "inherit"
+      }).unref();
+      return Response.json({ ok: !0, message: `Deployment started for ${basename(project)}` });
+    }
+    case "deploy-logs":
+      openPath(join(project, "storage/logs"));
+      return Response.json({ ok: !0, message: "Opened deployment logs" });
+    case "site-logs":
+      openPath(join(project, "storage/logs"));
+      return Response.json({ ok: !0, message: "Opened site logs" });
+    case "error-logs":
+      openPath(join(project, "storage/logs"));
+      return Response.json({ ok: !0, message: "Opened error logs" });
+    case "edit-env":
+      openPath(join(project, ".env"));
+      return Response.json({ ok: !0, message: "Opened .env" });
+    case "edit-dns":
+      openPath(join(project, "config/dns.ts"));
+      return Response.json({ ok: !0, message: "Opened DNS configuration" });
+    case "edit-email":
+      openPath(join(project, "config/email.ts"));
+      return Response.json({ ok: !0, message: "Opened email configuration" });
+    case "ask-buddy":
+      openPath(dashboardUrl("/buddy"));
+      return Response.json({ ok: !0, message: "Opened Ask Buddy" });
+    default:
+      return Response.json({ ok: !1, error: "Unknown tray action" }, { status: 400 });
+  }
+}
+const { serve } = await import("bun-plugin-stx/serve"), serverPromise = serve({
+  patterns: [trayViews],
+  port,
+  componentsDir: storagePath("framework/defaults/resources/components"),
+  quiet: !0,
+  auth: !1,
+  routes: {
+    "/api/tray/projects": async () => Response.json({ ok: !0, projects: await discoverProjects() }),
+    "/api/tray/action": async (request) => {
+      if (request.method !== "POST")
+        return Response.json({ ok: !1, error: "Method not allowed" }, { status: 405 });
+      return handleAction(await request.json());
+    }
+  }
 });
+serverPromise.catch((error) => {
+  console.error(`System tray server failed: ${error.message}`);
+  process.exit(1);
+});
+let proxyStarted = !1;
+if (trayDomain && !process.env.STACKS_PROXY_MANAGED)
+  try {
+    const { startProxies } = await import("@stacksjs/rpx");
+    await startProxies({
+      proxies: [{ from: `localhost:${port}`, to: trayDomain, cleanUrls: !1 }],
+      https: { basePath: `${process.env.HOME}/.stacks/ssl`, validityDays: 825 },
+      regenerateUntrustedCerts: !1
+    });
+    proxyStarted = !0;
+  } catch {
+    proxyStarted = !1;
+  }
+await waitForServer(port, 2000);
+const url = trayDomain && proxyStarted ? `https://${trayDomain}` : localUrl;
+console.log();
+console.log(`  ${bold(cyan("stacks tray"))}`);
+console.log();
+console.log(`  ${green("\u279C")}  ${bold("Local")}:   ${cyan(url)}`);
+if (trayDomain)
+  console.log(`  ${dim("\u279C")}  ${dim("Origin")}:  ${dim(localUrl)}`);
+console.log();
+await openDevWindow(port, {
+  url,
+  title: "Stacks",
+  width: 440,
+  height: 680,
+  systemTray: !0,
+  hideDockIcon: !0,
+  hotReload: !0
+});
+const stop = () => {
+  process.exit(0);
+};
+process.on("SIGINT", stop);
+process.on("SIGTERM", stop);
+await new Promise(() => {});

package/dist/examples.js

@@ -5,7 +5,7 @@ import { hasComponents } from "@stacksjs/storage";
 import { ExitCode } from "@stacksjs/types";
 import { runNpmScript } from "@stacksjs/utils";
 export async function invoke(options) {
-  if (options.components || options.vue)
+  if (options.components)
     await componentExample(options);
   else if (options.webComponents || options.elements)
     await webComponentExample(options);
@@ -17,7 +17,7 @@ export async function examples(options) {
 }
 export async function componentExample(options) {
   if (hasComponents()) {
-    await runNpmScript(NpmScript.ExampleVue, options);
+    await runNpmScript(NpmScript.Example, options);
     log.success("Your component library was built successfully");
   } else
     log.info("No components found.");

package/dist/helpers/lib-entries.js

@@ -53,18 +53,18 @@ export function generateEntryPointData(type) {
 `);
   }
   arr = determineResetPreset();
-  const imports = [...arr, "import { defineCustomElement } from 'vue'"], declarations = [], definitions = [];
+  const imports = [...arr, "import { defineCustomElement } from '@stacksjs/stx'"], declarations = [], definitions = [];
   if (!library.webComponents?.tags) {
     log.error(Error("There are no components defined to be built. Please check your config/library.ts file for potential adjustments"));
     process.exit(ExitCode.FatalError);
   }
   for (const component of library.webComponents.tags.map((tag) => tag.name))
     if (Array.isArray(component)) {
-      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.vue'`);
+      imports.push(`import ${component[1]} from '${componentsPath(component[0])}.stx'`);
       declarations.push(`const ${component[1]}CustomElement = defineCustomElement(${component[1]})`);
       definitions.push(`customElements.define('${kebabCase(component[1])}', ${component[1]}CustomElement)`);
     } else {
-      imports.push(`import ${component} from '${componentsPath(component)}.vue'`);
+      imports.push(`import ${component} from '${componentsPath(component)}.stx'`);
       declarations.push(`const ${component}CustomElement = defineCustomElement(${component})`);
       definitions.push(`customElements.define('${kebabCase(component)}', ${component}CustomElement)`);
     }

package/dist/helpers/vscode-custom-data.d.ts

@@ -1,3 +1,4 @@
 import type { Result } from '@stacksjs/error-handling';
 export declare function generateVsCodeCustomData(): Promise<Result<void, string>>;
 export declare function generateWebTypes(): Promise<void>;
+export declare function generateWebTypesData(): string;

package/dist/helpers/vscode-custom-data.js

@@ -1,7 +1,7 @@
 import { library } from "@stacksjs/config";
 import { err, ok } from "@stacksjs/error-handling";
 import { log } from "@stacksjs/logging";
-import { customElementsDataPath } from "@stacksjs/path";
+import { customElementsDataPath, frameworkPath } from "@stacksjs/path";
 import { writeTextFile } from "@stacksjs/storage";
 function generateComponentInfoData() {
   return `{
@@ -26,5 +26,35 @@ export async function generateVsCodeCustomData() {
 }
 export async function generateWebTypes() {
   log.info("Generating web-types.json...");
-  log.info("This feature is not yet implemented.");
+  await writeTextFile({
+    path: frameworkPath("core/web-types.json"),
+    data: generateWebTypesData()
+  });
+  log.success("Generated web-types.json for IDEs.");
+}
+export function generateWebTypesData() {
+  const tags = (library.webComponents?.tags ?? []).map((tag) => {
+    const sourceName = Array.isArray(tag.name) ? tag.name[0] : tag.name;
+    return {
+      name: Array.isArray(tag.name) ? tag.name[1] : tag.name,
+      description: tag.description ?? "",
+      attributes: tag.attributes ?? [],
+      source: {
+        module: `../../defaults/resources/components/${sourceName}.stx`,
+        symbol: "default"
+      }
+    };
+  });
+  return `${JSON.stringify({
+    framework: "stx",
+    name: library.name,
+    contributions: {
+      html: {
+        "description-markup": "markdown",
+        "types-syntax": "typescript",
+        tags
+      }
+    }
+  }, null, 2)}
+`;
 }

package/dist/make.d.ts

@@ -13,6 +13,7 @@ export declare function makeAction(options: MakeOptions): Promise<void>;
 export declare function makeComponent(options: MakeOptions): Promise<void>;
 export declare function createAction(options: MakeOptions): Promise<void>;
 export declare function createComponent(options: MakeOptions): Promise<void>;
+export declare function componentFileName(name: string): string;
 export declare function makeDatabase(options: MakeOptions): void;
 export declare function createDatabase(options: MakeOptions): void;
 export declare function factory(options: MakeOptions): Promise<void>;
@@ -39,6 +40,7 @@ export declare function createMail(options: MakeOptions & { force?: boolean }):
 export declare function makeMail(options: MakeOptions & { force?: boolean }): Promise<void>;
 export declare function makePage(options: MakeOptions): Promise<void>;
 export declare function createPage(options: MakeOptions): Promise<void>;
+export declare function pageFileName(name: string): string;
 export declare function makeFunction(options: MakeOptions): Promise<void>;
 export declare function createFunction(options: MakeOptions): Promise<void>;
 export declare function makeLanguage(options: MakeOptions): Promise<void>;

package/dist/make.js

@@ -87,7 +87,10 @@ export async function createAction(options) {
 }
 export async function createComponent(options) {
   const name = options.name;
-  await createFileWithTemplate(p.userComponentsPath(`${name}.vue`), "component", name);
+  await createFileWithTemplate(p.userComponentsPath(componentFileName(name)), "component", name);
+}
+export function componentFileName(name) {
+  return `${name}.stx`;
 }
 export function makeDatabase(options) {
   try {
@@ -211,7 +214,10 @@ export async function makePage(options) {
 }
 export async function createPage(options) {
   const name = options.name;
-  await createFileWithTemplate(p.userViewsPath(`${name}.vue`), "page", name);
+  await createFileWithTemplate(p.userViewsPath(pageFileName(name)), "page", name);
+}
+export function pageFileName(name) {
+  return `${name}.stx`;
 }
 export async function makeFunction(options) {
   try {
@@ -262,10 +268,10 @@ export async function makeStack(options) {
     log.info("");
     log.info(`  cd ${name}`);
     log.info("  # Add your models, actions, views, etc.");
-    log.info("  # Then publish: bun publish");
+    log.info("  # Push the repository, then submit its GitHub source to the Stacks registry.");
     log.info("");
     log.info("  Users install it with:");
-    log.info(`  buddy stack:install ${name}`);
+    log.info(`  buddy add ${shortName}`);
   } catch (error) {
     log.error("There was an error creating your stack", error);
     process.exit(ExitCode.FatalError);

package/dist/stacks.d.ts

@@ -1,4 +1,4 @@
 import type { StackInstallOptions, StackListEntry, StackManifestEntry, StackUninstallOptions } from '@stacksjs/types';
 export declare function installStack(options: StackInstallOptions): Promise<StackManifestEntry | null>;
 export declare function uninstallStack(options: StackUninstallOptions): Promise<boolean>;
-export declare function listStacks(): Promise<StackListEntry[]>;
+export declare function listStacks(project?: string): Promise<StackListEntry[]>;