sst 1.16.0 → 2.0.0-rc.1

package/{dist/cli → cli}/commands/update.js

@@ -1,26 +1,17 @@
+import { green, yellow } from "colorette";
 import fs from "fs/promises";
 import path from "path";
-const SST_PACKAGES = [
-    "@serverless-stack/resources",
-    "@serverless-stack/cli",
-    "@serverless-stack/cli2",
-    "@serverless-stack/node",
-    "@serverless-stack/static-site-env",
-];
+const PACKAGE_MATCH = ["sst", "aws-cdk", "@aws-cdk"];
 const FIELDS = ["dependencies", "devDependencies"];
 export const update = (program) => program.command("update [ver]", "Update SST and CDK packages to another version", (yargs) => yargs.positional("ver", {
     type: "string",
     describe: "Optional SST version to update to",
 }), async (args) => {
     const { fetch } = await import("undici");
-    const { Logger } = await import("../../logger.js");
-    const { useProject } = await import("../../app");
+    const { useProject } = await import("../../app.js");
     const project = useProject();
     const files = await find(project.paths.root);
-    const version = args.version ||
-        (await fetch(`https://registry.npmjs.org/@serverless-stack/core/latest`)
-            .then((resp) => resp.json())
-            .then((resp) => resp.version));
+    const metadata = await fetch(`https://registry.npmjs.org/sst/${args.ver || "rc"}`).then((resp) => resp.json());
     const results = new Map();
     const tasks = files.map(async (file) => {
         const data = await fs
@@ -32,31 +23,36 @@ export const update = (program) => program.command("update [ver]", "Update SST a
             if (!deps)
                 continue;
             for (const [pkg, existing] of Object.entries(deps)) {
-                if (!SST_PACKAGES.includes(pkg) || existing === version)
+                if (!PACKAGE_MATCH.some((x) => pkg.startsWith(x)))
+                    continue;
+                const desired = pkg === "sst"
+                    ? metadata.version
+                    : metadata.dependencies["aws-cdk-lib"];
+                if (existing === desired)
                     continue;
                 let arr = results.get(file);
                 if (!arr) {
                     arr = new Set();
                     results.set(file, arr);
                 }
-                arr.add(pkg);
-                deps[pkg] = version;
+                arr.add([pkg, desired]);
+                deps[pkg] = desired;
             }
         }
         await fs.writeFile(file, JSON.stringify(data, null, 2));
     });
     await Promise.all(tasks);
     if (results.size === 0) {
-        Logger.ui("green", `All packages already match version ${version}`);
+        console.log(green(`All packages already match version ${metadata.version}`));
         return;
     }
     for (const [file, pkgs] of results.entries()) {
-        Logger.ui("green", `✅ ${path.relative(project.paths.root, file)}`);
-        for (const pkg of pkgs) {
-            Logger.ui("green", `     ${pkg}@${version}`);
+        console.log(green(`✅ ${path.relative(project.paths.root, file)}`));
+        for (const [pkg, version] of pkgs) {
+            console.log(green(`     ${pkg}@${version}`));
         }
     }
-    Logger.ui("yellow", "", "Don't forget to run your package manager to install the packages");
+    console.log(yellow("Don't forget to run your package manager to install the packages"));
 });
 async function find(dir) {
     const children = await fs.readdir(dir);

package/cli/local/router.d.ts

@@ -0,0 +1,42 @@
+import * as trpc from "@trpc/server";
+import { DendriformPatch } from "dendriform-immer-patch-optimiser";
+export declare type State = {
+    app: string;
+    stage: string;
+    functions: Record<string, FunctionState>;
+    live: boolean;
+    stacks: {
+        status: any;
+    };
+};
+export declare type FunctionState = {
+    state: "idle" | "building" | "checking";
+    invocations: Invocation[];
+    issues: Record<string, any[]>;
+    warm: boolean;
+};
+export declare type Invocation = {
+    id: string;
+    request: any;
+    response?: any;
+    times: {
+        start: number;
+        end?: number;
+    };
+    logs: {
+        message: string;
+        timestamp: number;
+    }[];
+};
+export declare type Context = {
+    state: State;
+};
+export declare const router: import("@trpc/server/dist/declarations/src/router.js").Router<Context, Context, Record<"getCredentials", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, {
+    region: string;
+    credentials: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken: string | undefined;
+    };
+}>> & Record<"getState", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, State>>, Record<"deploy", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, void>>, Record<"onStateChange", import("@trpc/server/dist/declarations/src/internals/procedure.js").Procedure<Context, Context, undefined, undefined, trpc.Subscription<DendriformPatch[]>>>, trpc.DefaultErrorShape>;
+export declare type Router = typeof router;

package/cli/local/router.js

@@ -0,0 +1,43 @@
+import * as trpc from "@trpc/server";
+import { useProject } from "../../app.js";
+import { useBus } from "../../bus.js";
+import { useAWSCredentials } from "../../credentials.js";
+export const router = trpc
+    .router()
+    .query("getCredentials", {
+    async resolve({ ctx }) {
+        const project = useProject();
+        const credentials = await useAWSCredentials();
+        return {
+            region: project.region,
+            credentials: {
+                accessKeyId: credentials.accessKeyId,
+                secretAccessKey: credentials.secretAccessKey,
+                sessionToken: credentials.sessionToken,
+            },
+        };
+    },
+})
+    .query("getState", {
+    async resolve({ ctx }) {
+        return ctx.state;
+    },
+})
+    .mutation("deploy", {
+    async resolve({ ctx }) {
+        return;
+    },
+})
+    .subscription("onStateChange", {
+    async resolve({ ctx }) {
+        const bus = useBus();
+        return new trpc.Subscription((emit) => {
+            const sub = bus.subscribe("local.patches", (evt) => {
+                emit.data(evt.properties);
+            });
+            return () => {
+                bus.unsubscribe(sub);
+            };
+        });
+    },
+});

package/cli/local/server.d.ts

@@ -0,0 +1,20 @@
+import { FunctionState, State } from "./router.js";
+import { WritableDraft } from "immer/dist/internal.js";
+import { DendriformPatch } from "dendriform-immer-patch-optimiser";
+declare type Opts = {
+    port: number;
+    key: any;
+    cert: any;
+    live: boolean;
+};
+declare module "../../bus.js" {
+    interface Events {
+        "local.patches": DendriformPatch[];
+    }
+}
+export declare function useLocalServer(opts: Opts): Promise<{
+    port: number;
+    updateState: (cb: (draft: WritableDraft<State>) => void) => void;
+    updateFunction: (id: string, cb: (draft: WritableDraft<FunctionState>) => void) => void;
+}>;
+export {};

package/cli/local/server.js

@@ -0,0 +1,212 @@
+import { produceWithPatches, enablePatches } from "immer";
+import express from "express";
+import fs from "fs/promises";
+enablePatches();
+import { WebSocketServer } from "ws";
+import https from "https";
+import http from "http";
+import { applyWSSHandler } from "@trpc/server/adapters/ws/dist/trpc-server-adapters-ws.cjs.js";
+import { router } from "./router.js";
+import { optimise } from "dendriform-immer-patch-optimiser";
+import { sync } from "cross-spawn";
+import { useProject } from "../../app.js";
+import { useBus } from "../../bus.js";
+export async function useLocalServer(opts) {
+    const project = useProject();
+    let state = {
+        app: project.name,
+        stage: project.stage,
+        live: opts.live,
+        stacks: {
+            status: "idle",
+        },
+        functions: {},
+    };
+    const rest = express();
+    /*
+    rest.all(`/ping`, (req, res) => {
+      res.header("Access-Control-Allow-Origin", "*");
+      res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
+      res.header(
+        "Access-Control-Allow-Headers",
+        req.header("access-control-request-headers")
+      );
+      res.sendStatus(200);
+    });
+    */
+    rest.all(`/proxy*`, express.raw({
+        type: "*/*",
+        limit: "1024mb",
+    }), (req, res) => {
+        res.header("Access-Control-Allow-Origin", "*");
+        res.header("Access-Control-Allow-Methods", "GET, PUT, PATCH, POST, DELETE");
+        res.header("Access-Control-Allow-Headers", req.header("access-control-request-headers"));
+        if (req.method === "OPTIONS")
+            return res.send();
+        const u = new URL(req.url.substring(7));
+        const forward = https.request(u, {
+            headers: {
+                ...req.headers,
+                host: u.hostname,
+            },
+            method: req.method,
+        }, (proxied) => {
+            res.status(proxied.statusCode);
+            for (const [key, value] of Object.entries(proxied.headers)) {
+                res.header(key, value);
+            }
+            proxied.pipe(res);
+        });
+        if (req.method !== "GET" &&
+            req.method !== "DELETE" &&
+            req.method !== "HEAD" &&
+            req.body)
+            forward.write(req.body);
+        forward.end();
+        forward.on("error", (e) => {
+            console.log(e.message);
+        });
+    });
+    const server = await (async () => {
+        const result = sync("mkcert", ["--help"]);
+        const KEY_PATH = ".sst/localhost-key.pem";
+        const CERT_PATH = ".sst/localhost.pem";
+        if (result.status === 0) {
+            try {
+                await Promise.all([fs.access(KEY_PATH), fs.access(CERT_PATH)]);
+            }
+            catch (e) {
+                sync("mkcert", ["localhost"], {
+                    cwd: ".sst",
+                });
+            }
+            const [key, cert] = await Promise.all([
+                fs.readFile(KEY_PATH),
+                fs.readFile(CERT_PATH),
+            ]);
+            return https.createServer({
+                key: key,
+                cert: cert,
+            }, rest);
+        }
+        return http.createServer({}, rest);
+    })();
+    // Wire up websocket
+    const wss = new WebSocketServer({ server });
+    wss.on("connection", (socket, req) => {
+        if (req.headers.origin?.endsWith("localhost:3000"))
+            return;
+        if (req.headers.origin?.endsWith("localhost:3001"))
+            return;
+        if (req.headers.origin?.endsWith("console.serverless-stack.com"))
+            return;
+        if (req.headers.origin?.endsWith("console.sst.dev"))
+            return;
+        if (req.headers.origin?.endsWith("--sst-console.netlify.app"))
+            return;
+        console.log("Rejecting unauthorized connection from " + req.headers.origin);
+        socket.terminate();
+    });
+    server.listen(opts.port);
+    const handler = applyWSSHandler({
+        wss,
+        router,
+        createContext() {
+            return {
+                state,
+            };
+        },
+    });
+    process.on("SIGTERM", () => {
+        handler.broadcastReconnectNotification();
+        wss.close();
+    });
+    const bus = useBus();
+    const pending = [];
+    function updateState(cb) {
+        const [next, patches] = produceWithPatches(state, cb);
+        if (!patches.length)
+            return;
+        const scheduled = pending.length;
+        pending.push(...optimise(state, patches));
+        if (!scheduled)
+            setTimeout(() => {
+                bus.publish("local.patches", pending);
+                pending.splice(0, pending.length);
+            }, 0);
+        state = next;
+    }
+    function updateFunction(id, cb) {
+        return updateState((draft) => {
+            let func = draft.functions[id];
+            if (!func) {
+                func = {
+                    warm: true,
+                    state: "idle",
+                    issues: {},
+                    invocations: [],
+                };
+                draft.functions[id] = func;
+            }
+            cb(func);
+        });
+    }
+    bus.subscribe("function.invoked", (evt) => {
+        updateFunction(evt.properties.functionID, (draft) => {
+            if (draft.invocations.length >= 25)
+                draft.invocations.pop();
+            draft.invocations.unshift({
+                id: evt.properties.context.awsRequestId,
+                request: evt.properties.event,
+                times: {
+                    start: Date.now(),
+                },
+                logs: [],
+            });
+        });
+    });
+    bus.subscribe("worker.stdout", (evt) => {
+        updateFunction(evt.properties.functionID, (draft) => {
+            const entry = draft.invocations.find((i) => i.id === evt.properties.requestID);
+            if (!entry)
+                return;
+            entry.logs.push({
+                timestamp: Date.now(),
+                message: evt.properties.message,
+            });
+        });
+    });
+    bus.subscribe("function.success", (evt) => {
+        updateFunction(evt.properties.functionID, (draft) => {
+            const invocation = draft.invocations.find((x) => x.id === evt.properties.requestID);
+            if (!invocation)
+                return;
+            invocation.response = {
+                type: "success",
+                data: evt.properties.body,
+            };
+            invocation.times.end = Date.now();
+        });
+    });
+    bus.subscribe("function.error", (evt) => {
+        updateFunction(evt.properties.functionID, (draft) => {
+            const invocation = draft.invocations.find((x) => x.id === evt.properties.requestID);
+            if (!invocation)
+                return;
+            invocation.response = {
+                type: "failure",
+                error: {
+                    errorMessage: evt.properties.errorMessage,
+                    stackTrace: evt.properties.trace || [],
+                },
+            };
+            invocation.times.end = Date.now();
+        });
+    });
+    const result = {
+        port: opts.port,
+        updateState,
+        updateFunction,
+    };
+    return result;
+}

package/cli/program.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="yargs" />
+export declare const program: import("yargs").Argv<{
+    stage: string | undefined;
+} & {
+    profile: string | undefined;
+} & {
+    region: string | undefined;
+}>;
+export declare type Program = typeof program;

package/{dist/cli → cli}/program.js

@@ -1,7 +1,7 @@
 import yargs from "yargs";
-/* @ts-expect-error */
 import { hideBin } from "yargs/helpers";
 import { initProject } from "../app.js";
+import { trackCli } from "./telemetry/telemetry.js";
 export const program = yargs(hideBin(process.argv))
     .scriptName("sst")
     .option("stage", {
@@ -11,9 +11,14 @@ export const program = yargs(hideBin(process.argv))
     .option("profile", {
     type: "string",
     describe: "The AWS profile to use",
+})
+    .option("region", {
+    type: "string",
+    describe: "The AWS region to use",
 })
     .middleware(async (argv) => {
     await initProject(argv);
+    trackCli(argv._[0]);
 })
     .strict()
     .demandCommand(1);

package/cli/sst.d.ts

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

package/{dist/cli → cli}/sst.js

@@ -1,5 +1,32 @@
+#!/usr/bin/env node
+import { blue, red } from "colorette";
+import { program } from "./program.js";
+import { secrets } from "./commands/secrets/secrets.js";
+import { update } from "./commands/update.js";
+import { dev } from "./commands/dev.js";
+import { bind } from "./commands/bind.js";
+import { build } from "./commands/build.js";
+import { VisibleError } from "../error.js";
+import { useSpinners } from "./spinner.js";
+import { deploy } from "./commands/deploy.js";
+import { remove } from "./commands/remove.js";
+import dotenv from "dotenv";
+import { env } from "./commands/env.js";
+import { Logger } from "../logger.js";
+import { consoleCommand } from "./commands/console.js";
+dotenv.config();
+secrets(program);
+update(program);
+dev(program);
+bind(program);
+build(program);
+deploy(program);
+remove(program);
+env(program);
+consoleCommand(program);
 process.removeAllListeners("uncaughtException");
 process.on("uncaughtException", (err) => {
+    Logger.debug(err);
     const spinners = useSpinners();
     for (const spinner of spinners) {
         if (spinner.isSpinning)
@@ -15,22 +42,6 @@ process.on("uncaughtException", (err) => {
     process.exit(1);
 });
 process.on("beforeExit", () => { });
-import { blue, red } from "colorette";
-import { program } from "./program.js";
-import { secrets } from "./commands/secrets/secrets.js";
-import { update } from "./commands/update.js";
-import { start } from "./commands/start.js";
-import { bind } from "./commands/bind.js";
-import { build } from "./commands/build.js";
-import { VisibleError } from "../error.js";
-import { useSpinners } from "./spinner.js";
-import { deploy } from "./commands/deploy.js";
-secrets(program);
-update(program);
-start(program);
-bind(program);
-build(program);
-deploy(program);
 program
     .fail((msg, error) => {
     if (!error) {

package/cli/telemetry/environment.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+declare 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

@@ -0,0 +1,27 @@
+import os from "os";
+import ciInfo from "ci-info";
+import { useProject } from "../../app.js";
+let data;
+export function getEnvironmentData() {
+    if (data) {
+        return data;
+    }
+    const cpus = os.cpus() || [];
+    const isSeed = !!process.env.SEED_APP_NAME;
+    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 || isSeed,
+        ciName: (isSeed ? "Seed" : ciInfo.name) || null,
+        sstVersion: useProject().version,
+    };
+    return data;
+}

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

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

package/cli/telemetry/post-payload.js

@@ -0,0 +1,18 @@
+import https from "https";
+export function postPayload(endpoint, body) {
+    return new Promise((resolve, reject) => {
+        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();
+        });
+        req.write(JSON.stringify(body));
+        req.end();
+    });
+}

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

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

package/cli/telemetry/project-id.js

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,4 @@
+export declare function enable(): void;
+export declare function disable(): void;
+export declare function isEnabled(): boolean;
+export declare function trackCli(command: string): void;