sst 3.0.0 → 3.0.1-2

package/cli/spinner.js

@@ -1,14 +0,0 @@
-import ora from "ora";
-import { Colors } from "./colors.js";
-import { lazy } from "../util/lazy.js";
-export const useSpinners = lazy(() => {
-    const spinners = [];
-    return spinners;
-});
-export function createSpinner(options) {
-    const spinners = useSpinners();
-    const next = ora(options);
-    spinners.push(next);
-    Colors.mode("line");
-    return next;
-}

package/cli/sst.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/cli/sst.js

@@ -1,74 +0,0 @@
-#!/usr/bin/env node
-import { blue, red } from "colorette";
-import { program } from "./program.js";
-import { SilentError, VisibleError } from "../error.js";
-import { useSpinners } from "./spinner.js";
-import { Logger } from "../logger.js";
-import dotenv from "dotenv";
-dotenv.config({
-    override: true,
-});
-dotenv.config({
-    path: ".env.local",
-    override: true,
-});
-import { bootstrap } from "./commands/bootstrap.js";
-import { dev } from "./commands/dev.js";
-import { bind } from "./commands/bind.js";
-import { build } from "./commands/build.js";
-import { deploy } from "./commands/deploy.js";
-import { remove } from "./commands/remove.js";
-import { consoleCommand } from "./commands/console.js";
-import { secrets } from "./commands/secrets/secrets.js";
-import { update } from "./commands/update.js";
-import { transform } from "./commands/transform.js";
-import { diff } from "./commands/diff.js";
-import { version } from "./commands/version.js";
-import { telemetry } from "./commands/telemetry.js";
-import { types } from "./commands/types.js";
-import { connect } from "./commands/connect.js";
-bootstrap(program);
-dev(program);
-deploy(program);
-build(program);
-bind(program);
-secrets(program);
-remove(program);
-update(program);
-transform(program);
-consoleCommand(program);
-diff(program);
-version(program);
-telemetry(program);
-types(program);
-connect(program);
-if ("setSourceMapsEnabled" in process) {
-    // @ts-expect-error
-    process.setSourceMapsEnabled(true);
-}
-process.removeAllListeners("uncaughtException");
-process.on("uncaughtException", (err) => {
-    Logger.debug(err);
-    const spinners = useSpinners();
-    for (const spinner of spinners) {
-        if (spinner.isSpinning)
-            spinner.fail(spinner.text);
-    }
-    if (!(err instanceof SilentError)) {
-        console.log();
-        console.log(red("Error:"), err.message);
-        if (!(err instanceof VisibleError)) {
-            console.log();
-            console.trace(err.stack);
-        }
-        console.log();
-        console.log(`Need help with this error? Post it in #help on the SST Discord ${blue(`https://sst.dev/discord`)}`);
-    }
-    process.exit(1);
-});
-// Check Node version
-const nodeVersion = process.versions.node;
-if (Number(nodeVersion.split(".")[0]) < 16) {
-    throw new VisibleError(`Node.js version ${nodeVersion} is not supported by SST. Please upgrade to Node.js 16 or later.`);
-}
-program.parse();

package/cli/telemetry/environment.d.ts

@@ -1,15 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-type EnvironmentData = {
-    systemPlatform: NodeJS.Platform;
-    systemRelease: string;
-    systemArchitecture: string;
-    cpuCount: number;
-    cpuModel: string | null;
-    cpuSpeed: number | null;
-    memoryInMb: number;
-    isCI: boolean;
-    ciName: string | null;
-    sstVersion: string;
-};
-export declare function getEnvironmentData(): EnvironmentData;
-export {};

package/cli/telemetry/environment.js

@@ -1,27 +0,0 @@
-import os from "os";
-import { getCiInfo } from "../ci-info.js";
-import { useProject } from "../../project.js";
-let data;
-export function getEnvironmentData() {
-    if (data) {
-        return data;
-    }
-    const cpus = os.cpus() || [];
-    const ciInfo = getCiInfo();
-    data = {
-        // Software information
-        systemPlatform: os.platform(),
-        systemRelease: os.release(),
-        systemArchitecture: os.arch(),
-        // Machine information
-        cpuCount: cpus.length,
-        cpuModel: cpus.length ? cpus[0].model : null,
-        cpuSpeed: cpus.length ? cpus[0].speed : null,
-        memoryInMb: Math.trunc(os.totalmem() / Math.pow(1024, 2)),
-        // Environment information
-        isCI: ciInfo.isCI,
-        ciName: ciInfo.name,
-        sstVersion: useProject().version,
-    };
-    return data;
-}

package/cli/telemetry/post-payload.d.ts

@@ -1 +0,0 @@
-export declare function postPayload(endpoint: string, body: any): Promise<void>;

package/cli/telemetry/post-payload.js

@@ -1,27 +0,0 @@
-import https from "https";
-export function postPayload(endpoint, body) {
-    return new Promise((resolve, reject) => {
-        try {
-            const req = https
-                .request(endpoint, {
-                method: "POST",
-                headers: { "content-type": "application/json" },
-                timeout: 5000,
-            }, (resp) => {
-                if (resp.statusCode !== 200) {
-                    reject(new Error(`Unexpected status code: ${resp.statusCode}`));
-                    return;
-                }
-                resolve();
-            })
-                .on("error", () => {
-                // catches connect ECONNREFUSED while the below catch does not work as expected
-            });
-            req.write(JSON.stringify(body));
-            req.end();
-        }
-        catch (ex) {
-            reject(ex);
-        }
-    });
-}

package/cli/telemetry/project-id.d.ts

@@ -1,2 +0,0 @@
-export declare function normalizeGitUrl(url: string): string;
-export declare function getRawProjectId(): string;

package/cli/telemetry/project-id.js

@@ -1,47 +0,0 @@
-import { execSync } from "child_process";
-function getProjectIdByGit() {
-    try {
-        const originBuffer = execSync(`git config --local --get remote.origin.url`, {
-            timeout: 1000,
-            stdio: `pipe`,
-        });
-        return String(originBuffer).trim();
-    }
-    catch (_) {
-        return null;
-    }
-}
-export function normalizeGitUrl(url) {
-    // Normalize url
-    // - https://x-access-token:ghs_xxxx@github.com/user/repo.git
-    // - https://github.com/user/repo.git
-    // - git@github.com:user/repo.git
-    // trim
-    url = url.trim();
-    // clean up ending `.git`
-    url = url.endsWith(".git") ? url.substring(0, url.length - 4) : url;
-    if (url.startsWith("git@")) {
-        const match = url.match(/git@([^:]+):(.*)/);
-        if (match && match.length > 2) {
-            return `${match[1]}/${match[2]}`;
-        }
-    }
-    else if (url.startsWith("http://") || url.startsWith("https://")) {
-        const match = url.match(/https?:\/\/([^@]+@)?(.*)/);
-        if (match && match.length > 2) {
-            return match[2];
-        }
-    }
-    return url;
-}
-export function getRawProjectId() {
-    const gitUrl = getProjectIdByGit();
-    if (gitUrl) {
-        return normalizeGitUrl(gitUrl);
-    }
-    const repoUrl = process.env.REPOSITORY_URL;
-    if (repoUrl) {
-        return normalizeGitUrl(repoUrl);
-    }
-    return process.cwd();
-}

package/cli/telemetry/telemetry.d.ts

@@ -1,19 +0,0 @@
-type CliFailedEvent = {
-    rawCommand: string;
-    duration: number;
-    errorName: string;
-    errorMessage: string;
-};
-type CliSucceededEvent = {
-    rawCommand: string;
-    duration: number;
-};
-export declare function enable(): void;
-export declare function disable(): void;
-export declare function isEnabled(): boolean;
-export declare function trackCli(command: string): Promise<any>;
-export declare function trackCliFailed(event: CliFailedEvent): Promise<any>;
-export declare function trackCliSucceeded(event: CliSucceededEvent): Promise<any>;
-export declare function trackCliDevError(event: CliFailedEvent): Promise<any>;
-export declare function trackCliDevRunning(event: CliSucceededEvent): Promise<any>;
-export {};

package/cli/telemetry/telemetry.js

@@ -1,103 +0,0 @@
-import Conf from "conf";
-import { createHash, randomBytes } from "crypto";
-import { postPayload } from "./post-payload.js";
-import { getRawProjectId } from "./project-id.js";
-import { getEnvironmentData } from "./environment.js";
-import { cyan } from "colorette";
-const TELEMETRY_API = "https://telemetry.sst.dev/events";
-const TELEMETRY_KEY_ENABLED = "telemetry.enabled";
-const TELEMETRY_KEY_NOTIFY_DATE = "telemetry.notifiedAt";
-const TELEMETRY_KEY_ID = `telemetry.anonymousId`;
-const conf = initializeConf();
-const sessionId = randomBytes(32).toString("hex");
-const projectId = hash(getRawProjectId());
-const anonymousId = getAnonymousId();
-notify();
-export function enable() {
-    conf && conf.set(TELEMETRY_KEY_ENABLED, true);
-}
-export function disable() {
-    conf && conf.set(TELEMETRY_KEY_ENABLED, false);
-}
-export function isEnabled() {
-    if (!conf) {
-        return false;
-    }
-    return conf.get(TELEMETRY_KEY_ENABLED, true) !== false;
-}
-export function trackCli(command) {
-    return record("CLI_COMMAND", { command });
-}
-export function trackCliFailed(event) {
-    return record("CLI_COMMAND_FAILED", event);
-}
-export function trackCliSucceeded(event) {
-    return record("CLI_COMMAND_SUCCEEDED", event);
-}
-export function trackCliDevError(event) {
-    return record("CLI_COMMAND_DEV_ERROR", event);
-}
-export function trackCliDevRunning(event) {
-    return record("CLI_COMMAND_DEV_RUNNING", event);
-}
-function initializeConf() {
-    try {
-        // @ts-expect-error
-        return new Conf({ projectName: "sst" });
-    }
-    catch (_) {
-        return null;
-    }
-}
-function notify() {
-    if (!conf || willNotRecord()) {
-        return;
-    }
-    // Do not notify if user has been notified before.
-    if (conf.get(TELEMETRY_KEY_NOTIFY_DATE) !== undefined) {
-        return;
-    }
-    conf.set(TELEMETRY_KEY_NOTIFY_DATE, Date.now().toString());
-    console.log(`${cyan("Attention")}: SST now collects completely anonymous telemetry regarding usage. This is used to guide SST's roadmap.`);
-    console.log(`You can learn more, including how to opt-out of this anonymous program, by heading over to:`);
-    console.log("https://docs.sst.dev/anonymous-telemetry");
-    console.log();
-}
-function willNotRecord() {
-    return !isEnabled() || !!process.env.SST_TELEMETRY_DISABLED;
-}
-async function record(name, properties) {
-    if (willNotRecord()) {
-        return Promise.resolve();
-    }
-    const context = {
-        anonymousId,
-        projectId,
-        sessionId,
-    };
-    try {
-        await postPayload(TELEMETRY_API, {
-            context,
-            environment: getEnvironmentData(),
-            events: [
-                {
-                    name,
-                    properties,
-                },
-            ],
-        });
-    }
-    catch { }
-}
-function getAnonymousId() {
-    const val = conf && conf.get(TELEMETRY_KEY_ID);
-    if (val) {
-        return val;
-    }
-    const generated = randomBytes(32).toString("hex");
-    conf && conf.set(TELEMETRY_KEY_ID, generated);
-    return generated;
-}
-function hash(payload) {
-    return createHash("sha256").update(payload).digest("hex");
-}

package/cli/terminal.d.ts

@@ -1 +0,0 @@
-export declare function clear(): void;

package/cli/terminal.js

@@ -1,8 +0,0 @@
-export function clear() {
-    // console.clear() removes the content in the viewport in VSCode
-    // and on Windows. This is a workaround to preserve the viewport.
-    for (let i = 0, l = process.stdout.rows; i < l - 1; i++) {
-        console.log("");
-    }
-    console.clear();
-}

package/cli/ui/deploy.d.ts

@@ -1,10 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-import { Stacks } from "../../stacks/index.js";
-import type { CloudAssembly } from "aws-cdk-lib/cx-api";
-interface Props {
-    assembly: CloudAssembly;
-    remove?: boolean;
-}
-export declare const DeploymentUI: (props: Props) => JSX.Element;
-export declare function printDeploymentResults(assembly: CloudAssembly, results: Awaited<ReturnType<typeof Stacks.deployMany>>, remove?: boolean): void;
-export {};

package/cli/ui/deploy.js

@@ -1,172 +0,0 @@
-import React, { useState, useEffect } from "react";
-import { Box, Text } from "ink";
-import { useBus } from "../../bus.js";
-import { Stacks } from "../../stacks/index.js";
-import Spinner from "ink-spinner";
-import { Colors } from "../colors.js";
-import { useProject } from "../../project.js";
-export const DeploymentUI = (props) => {
-    const [statuses, setStatuses] = useState({});
-    const [resources, setResources] = useState({});
-    useEffect(() => {
-        Colors.gap();
-        const bus = useBus();
-        const status = bus.subscribe("stack.status", (payload) => {
-            const { stackID, status } = payload.properties;
-            setStatuses((previous) => {
-                if (status !== "PUBLISH_ASSETS_IN_PROGRESS") {
-                    if (previous[stackID]) {
-                        Colors.line(Colors.warning(Colors.prefix), Colors.dim(stackNameToId(stackID)), Colors.dim("PUBLISH_ASSETS_COMPLETE"), "");
-                    }
-                    const { [stackID]: _, ...next } = previous;
-                    return next;
-                }
-                return {
-                    ...previous,
-                    [stackID]: status,
-                };
-            });
-        });
-        const event = bus.subscribe("stack.event", (payload) => {
-            const { event } = payload.properties;
-            setResources((previous) => {
-                if (Stacks.isFinal(event.ResourceStatus)) {
-                    const readable = logicalIdToCdkPath(props.assembly, event.StackName, event.LogicalResourceId);
-                    Colors.line(Colors.warning(Colors.prefix), readable
-                        ? Colors.dim(`${stackNameToId(event.StackName)} ${readable} ${event.ResourceType}`)
-                        : Colors.dim(`${stackNameToId(event.StackName)} ${event.ResourceType}`), Stacks.isFailed(event.ResourceStatus)
-                        ? Colors.danger(event.ResourceStatus)
-                        : Colors.dim(event.ResourceStatus), Stacks.isFailed(event.ResourceStatus) && event.ResourceStatusReason
-                        ? event.ResourceStatusReason
-                        : "");
-                    const { [event.LogicalResourceId]: _, ...next } = previous;
-                    return next;
-                }
-                return {
-                    ...previous,
-                    [payload.properties.event.LogicalResourceId]: payload.properties.event,
-                };
-            });
-        });
-        return () => {
-            bus.unsubscribe(event);
-            bus.unsubscribe(status);
-        };
-    }, []);
-    function color(status) {
-        if (Stacks.isFailed(status))
-            return "red";
-        if (Stacks.isSuccess(status))
-            return "green";
-        return "yellow";
-    }
-    return (React.createElement(Box, { flexDirection: "column" },
-        Object.entries(statuses)
-            .slice(0, process.stdout.rows - 2)
-            .map(([stack, status], index) => {
-            return (React.createElement(Box, { key: index },
-                React.createElement(Text, null,
-                    React.createElement(Spinner, null),
-                    "  ",
-                    stackNameToId(stack),
-                    " "),
-                React.createElement(Text, { color: color(status) }, status)));
-        }),
-        Object.entries(resources)
-            .slice(0, Math.max(0, process.stdout.rows - Object.entries(statuses).length - 2))
-            .map(([_, evt], index) => {
-            const readable = logicalIdToCdkPath(props.assembly, evt.StackName, evt.LogicalResourceId);
-            return (React.createElement(Box, { key: index },
-                React.createElement(Text, null,
-                    React.createElement(Spinner, null),
-                    "  ",
-                    readable
-                        ? `${stackNameToId(evt.StackName)} ${readable} ${evt.ResourceType}`
-                        : `${stackNameToId(evt.StackName)} ${evt.ResourceType}`,
-                    " "),
-                React.createElement(Text, { color: color(evt.ResourceStatus || "") }, evt.ResourceStatus)));
-        }),
-        Object.entries(resources).length === 0 &&
-            Object.entries(statuses).length === 0 && (React.createElement(Box, null,
-            React.createElement(Text, null,
-                React.createElement(Spinner, null),
-                "  ",
-                React.createElement(Text, { dimColor: true }, props.remove ? "Removing..." : "Deploying..."))))));
-};
-export function printDeploymentResults(assembly, results, remove) {
-    // Print success stacks
-    const success = Object.entries(results).filter(([_stack, result]) => Stacks.isSuccess(result.status));
-    if (success.length) {
-        Colors.gap();
-        Colors.line(Colors.success(`✔`), Colors.bold(remove ? ` Removed:` : ` Deployed:`));
-        for (const [stack, result] of success) {
-            Colors.line(`   ${Colors.dim(stackNameToId(stack))}`);
-            for (const key of Object.keys(result.outputs).sort()) {
-                const value = result.outputs[key];
-                Colors.line(`   ${Colors.bold.dim(key + ":")} ${value}`);
-            }
-        }
-        Colors.gap();
-    }
-    // Print failed stacks
-    const failed = Object.entries(results).filter(([_stack, result]) => Stacks.isFailed(result.status));
-    if (failed.length) {
-        Colors.gap();
-        Colors.line(`${Colors.danger(`✖`)}  ${Colors.bold.dim(`Errors`)}`);
-        for (const [stack, result] of failed) {
-            Colors.line(`   ${Colors.dim(stackNameToId(stack))} ${Colors.dim(result.status)}`);
-            for (const [id, error] of Object.entries(result.errors)) {
-                const readable = logicalIdToCdkPath(assembly, stack, id) || id;
-                Colors.line(`   ${Colors.danger.bold(readable + ":")} ${error}`);
-                const helper = getHelper(error);
-                if (helper) {
-                    Colors.line(`   ${Colors.warning.bold("⮑  Hint:")} ${helper}`);
-                }
-            }
-        }
-        Colors.gap();
-    }
-}
-function stackNameToId(stack) {
-    const project = useProject();
-    const prefix = `${project.config.stage}-${project.config.name}-`;
-    return stack.startsWith(prefix) ? stack.substring(prefix.length) : stack;
-}
-function logicalIdToCdkPath(assembly, stack, logicalId) {
-    const found = Object.entries(assembly.manifest.artifacts?.[stack]?.metadata || {}).find(([_key, value]) => value[0]?.type === "aws:cdk:logicalId" && value[0]?.data === logicalId)?.[0];
-    if (!found) {
-        return;
-    }
-    return found.split("/").filter(Boolean).slice(1, -1).join("/");
-}
-function getHelper(error) {
-    return (getCloudFrontBehaviorLimitHelper(error) ||
-        getApiAccessLogPermissionsHelper(error) ||
-        getAppSyncMultiResolverHelper(error) ||
-        getApiLogRoleHelper(error));
-}
-function getCloudFrontBehaviorLimitHelper(error) {
-    if (error.indexOf("Your request contains more CacheBehaviors than are allowed per distribution.") > -1) {
-        return `This error often occurs when deploying a frontend with a large number of top-level files and folders in the assets directory. Check out this doc on how to resolve the issue - https://docs.sst.dev/known-issues#cloudfront-cachebehaviors-limit-exceeded`;
-    }
-}
-function getApiAccessLogPermissionsHelper(error) {
-    // Can run into this issue when enabling access logs for API Gateway
-    // note: this should be handled in SST as access log group names are now
-    //       hardcoded with /aws/vendedlogs/apis prefix.
-    if (error.indexOf("Insufficient permissions to enable logging") > -1) {
-        return `This is a common deploy error. Check out this GitHub issue for more details - https://github.com/sst/sst/issues/125`;
-    }
-}
-function getAppSyncMultiResolverHelper(error) {
-    // Can run into this issue when updating an AppSyncApi resolver
-    if (error.indexOf("Only one resolver is allowed per field. (Service: AWSAppSync") > -1) {
-        return `This is a common error for deploying AppSync APIs. Check out this GitHub issue for more details - https://github.com/aws/aws-cdk/issues/13269`;
-    }
-}
-function getApiLogRoleHelper(error) {
-    // Can run into this issue when enabling access logs for WebSocketApi
-    if (error.indexOf("CloudWatch Logs role ARN must be set in account settings to enable logging (Service: AmazonApiGatewayV2") > -1) {
-        return `This is a common error when configuring Access Log for WebSocket APIs. The AWS API Gateway service in your AWS account does not have permissions to the CloudWatch logs service. Follow this article to create an IAM role for logging to CloudWatch - https://aws.amazon.com/premiumsupport/knowledge-center/api-gateway-cloudwatch-logs/`;
-    }
-}

package/cli/ui/functions.d.ts

@@ -1,2 +0,0 @@
-/// <reference types="react" resolution-mode="require"/>
-export declare function Functions(): JSX.Element;

package/cli/ui/functions.js

@@ -1,130 +0,0 @@
-import { dim } from "colorette";
-import { Text } from "ink";
-import Spinner from "ink-spinner";
-import React, { useEffect, useState } from "react";
-import { useBus } from "../../bus.js";
-import { useFunctions } from "../../constructs/Function.js";
-import { Colors } from "../colors.js";
-export function Functions() {
-    const [functions, setFunctions] = useState({});
-    useEffect(() => {
-        const bus = useBus();
-        const invoke = bus.subscribe("function.invoked", (evt) => {
-            setFunctions((functions) => {
-                setTimeout(() => {
-                    setFunctions((functions) => {
-                        const existing = functions[evt.properties.requestID];
-                        if (!existing)
-                            return functions;
-                        return { ...functions };
-                    });
-                }, 500);
-                return {
-                    ...functions,
-                    [evt.properties.requestID]: {
-                        requestID: evt.properties.requestID,
-                        functionID: evt.properties.functionID,
-                        started: Date.now(),
-                        logs: [],
-                    },
-                };
-            });
-        });
-        const stdout = bus.subscribe("worker.stdout", (evt) => {
-            setFunctions((functions) => {
-                const existing = functions[evt.properties.requestID];
-                if (!existing)
-                    return functions;
-                return {
-                    ...functions,
-                    [evt.properties.requestID]: {
-                        ...existing,
-                        logs: [...existing.logs, evt.properties.message],
-                    },
-                };
-            });
-        });
-        // This is all ugly but the timeouts are for UI smootheness
-        const success = bus.subscribe("function.success", (evt) => {
-            function print(input, diff) {
-                setTimeout(() => {
-                    console.log(Colors.primary(`  ➜ `), useFunctions().fromID(input.functionID)?.handler);
-                    for (const log of input.logs) {
-                        console.log(`     ${dim(log)}`);
-                    }
-                    console.log(`     ${dim(`Done in ${diff}ms`)}`);
-                    console.log();
-                }, diff > 500 ? 60 : 0);
-            }
-            setFunctions((functions) => {
-                const { [evt.properties.requestID]: existing, ...next } = functions;
-                if (!existing)
-                    return functions;
-                const diff = Date.now() - existing.started;
-                if (diff > 500 && diff < 1500) {
-                    setTimeout(() => {
-                        setFunctions((functions) => {
-                            const { [evt.properties.requestID]: existing, ...next } = functions;
-                            print(existing, diff);
-                            return next;
-                        });
-                    }, 1500 - diff);
-                    return functions;
-                }
-                print(existing, diff);
-                return next;
-            });
-        });
-        const error = bus.subscribe("function.error", (evt) => {
-            function print(input, diff) {
-                setTimeout(() => {
-                    console.log(Colors.primary(`  ➜ `), useFunctions().fromID(input.functionID)?.handler);
-                    for (const log of input.logs) {
-                        console.log(`     ${dim(log)}`);
-                    }
-                    console.log(`     ${Colors.danger(evt.properties.errorMessage)}`);
-                    for (const line of evt.properties.trace || []) {
-                        console.log(`     ${dim(line)}`);
-                    }
-                    console.log();
-                }, diff > 500 ? 60 : 0);
-            }
-            setFunctions((functions) => {
-                const { [evt.properties.requestID]: existing, ...next } = functions;
-                if (!existing)
-                    return functions;
-                const diff = Date.now() - existing.started;
-                if (diff > 500 && diff < 1500) {
-                    setTimeout(() => {
-                        setFunctions((functions) => {
-                            const { [evt.properties.requestID]: existing, ...next } = functions;
-                            print(existing, diff);
-                            return next;
-                        });
-                    }, 1500 - diff);
-                    return functions;
-                }
-                print(existing, diff);
-                return next;
-            });
-        });
-        return () => {
-            bus.unsubscribe(invoke);
-            bus.unsubscribe(success);
-            bus.unsubscribe(error);
-            bus.unsubscribe(stdout);
-        };
-    }, []);
-    return (React.createElement(React.Fragment, null, Object.values(functions)
-        .filter((f) => Date.now() - f.started >= 500)
-        .map((evt) => (React.createElement(React.Fragment, { key: evt.requestID },
-        React.createElement(Text, null,
-            "  ",
-            React.createElement(Spinner, null),
-            "  ",
-            useFunctions().fromID(evt.functionID)?.handler),
-        evt.logs.map((log, index) => (React.createElement(Text, { dimColor: true, key: index },
-            "     ",
-            log))),
-        React.createElement(Text, null, " "))))));
-}