attio 0.0.1-experimental.20250303 → 0.0.1-experimental.20250321

package/lib/api/fetch-workspaces.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+import { APP } from "../env.js";
+import { handleError } from "./handle-error.js";
+import { makeHeaders } from "./make-headers.js";
+const workspacesResponseSchema = z.array(z.object({
+    workspace: z.object({
+        id: z.string(),
+        name: z.string(),
+        slug: z.string(),
+    }),
+    membership: z.object({
+        access_level: z.enum(["admin", "member", "suspended"]),
+    }),
+}));
+export async function fetchWorkspaces({ token }) {
+    const response = await fetch(`${APP}/api/common/workspaces`, {
+        method: "GET",
+        headers: makeHeaders(token),
+    });
+    await handleError(response);
+    return workspacesResponseSchema
+        .parse(await response.json())
+        .map(({ workspace, membership }) => ({ ...workspace, ...membership }));
+}

package/lib/attio.js

@@ -3,7 +3,6 @@ import { Command } from "commander";
 import { init } from "./commands/init.js";
 import { build } from "./commands/build.js";
 import { dev } from "./commands/dev.js";
-import { connection } from "./commands/connection/index.js";
 import { version } from "./commands/version/index.js";
 const program = new Command();
 program
@@ -13,6 +12,5 @@ program
     .addCommand(init)
     .addCommand(build)
     .addCommand(dev)
-    .addCommand(connection)
     .addCommand(version)
     .parse();

package/lib/commands/version/index.js

@@ -1,9 +1,7 @@
 import { Command } from "commander";
 import { versionCreate } from "./create.js";
 import { versionList } from "./list.js";
-import { versionPublish } from "./publish.js";
 export const version = new Command("version")
     .description("Manage app versions")
     .addCommand(versionCreate)
-    .addCommand(versionList)
-    .addCommand(versionPublish);
+    .addCommand(versionList);

package/lib/machines/dev-machine.js

@@ -1,13 +1,13 @@
 import chokidar from "chokidar";
 import open from "open";
-import { assign, setup, enqueueActions } from "xstate";
+import { assign, setup, enqueueActions, fromPromise } from "xstate";
 import { APP } from "../env.js";
 import { completeBundleUpload } from "../api/complete-bundle-upload.js";
 import { createDevVersion } from "../api/create-dev-version.js";
 import { startGraphqlServer } from "../api/start-graphql-server.js";
 import { startUpload } from "../api/start-upload.js";
 import { loadAppConfigFile } from "../util/app-config.js";
-import { loadDeveloperConfig, loadInitialDeveloperConfig, } from "../util/load-developer-config.js";
+import { loadDeveloperConfig, loadInitialDeveloperConfig, saveTargetWorkspaceToConfig, } from "../util/load-developer-config.js";
 import notifier from "node-notifier";
 import { loadEnv } from "../util/load-env.js";
 import { loadAttioCliPackageJson } from "../util/load-attio-cli-package-json.js";
@@ -23,7 +23,8 @@ import { clearTerminal } from "../util/clear-terminal.js";
 import { setTerminalTitle } from "../util/set-terminal-title.js";
 import { printInstallInstructions } from "../util/print-install-instructions.js";
 import { printLogo } from "./actions.js";
-import { fromCallbackWithErrorHandling } from "./actors.js";
+import { askWithTypedChoices, fromCallbackWithErrorHandling } from "./actors.js";
+import { fetchWorkspaces } from "../api/fetch-workspaces.js";
 process.on("SIGINT", () => {
     process.stdout.write("\x1B[?25h");
     process.exit();
@@ -40,12 +41,18 @@ export const devMachine = setup({
     guards: {
         "have dev version": ({ context }) => Boolean(context.devVersion),
         "have typescript errors": (_, params) => Boolean(params.typeScriptErrors?.length),
+        "have target workspace": (_, params) => Boolean(params.config?.target_workspace_id),
+        "have workspaces": (_, params) => Boolean(params.output?.length),
+        "is workspace admin": (_, params) => params.output.access_level === "admin",
+        "only one workspace and admin": (_, params) => params.output.length === 1 && params.output[0].access_level === "admin",
+        "only one workspace and not admin": (_, params) => params.output.length === 1 && params.output[0].access_level !== "admin",
     },
     actors: {
         "javascript": jsMachine,
         "typescript": tsMachine,
         "env": envMachine,
         "code-gen": codeGenMachine,
+        "askForWorkspace": askWithTypedChoices(),
         "loadConfig": fromCallbackWithErrorHandling(({ sendBack }) => {
             const config = loadInitialDeveloperConfig();
             if (typeof config === "string") {
@@ -98,6 +105,15 @@ export const devMachine = setup({
                 }
             };
         }),
+        "loadWorkspaces": fromPromise(async ({ input }) => await fetchWorkspaces({ token: input.token })),
+        "loadWorkspaceDetails": fromPromise(async ({ input }) => {
+            const workspaces = await fetchWorkspaces({ token: input.config.token });
+            const workspace = workspaces.find((workspace) => workspace.id === input.config.target_workspace_id);
+            if (!workspace) {
+                throw new Error(`Workspace not found: ${input.config.target_workspace_id}`);
+            }
+            return workspace;
+        }),
         "prepareUpload": fromCallbackWithErrorHandling(({ sendBack }) => {
             const prepareUpload = async () => {
                 const config = await loadDeveloperConfig();
@@ -248,8 +264,8 @@ export const devMachine = setup({
         printUploadError: (_, params) => {
             printMessage(params.uploadError.message);
         },
-        printGenericError: (_, params) => {
-            process.stderr.write(`${params.error.message}\n\n`);
+        printError: (_, params) => {
+            printMessage(params.error);
         },
         printLogo: (_) => {
             process.stdout.write("\x1B[?25l");
@@ -289,7 +305,7 @@ export const devMachine = setup({
             open(`http://localhost:${context.graphqlPort}/graphql`);
         },
         openInstallPage: ({ context }) => {
-            open(`${APP}/_/settings/apps/${context.devVersion?.app_slug}`);
+            open(`${APP}/${context.workspace.slug}/settings/apps/${context.devVersion?.app_slug}`);
         },
         saveTypeScriptErrors: assign({
             typeScriptErrors: (_, params) => params.errors,
@@ -329,6 +345,21 @@ export const devMachine = setup({
                 ? `attio dev – ${context.devVersion.app_id}`
                 : `attio dev`);
         },
+        setTargetWorkspace: assign({
+            config: (_, params) => ({
+                ...params.config,
+                target_workspace_id: params.workspace.id,
+            }),
+        }),
+        saveTargetWorkspaceToConfig: (_, params) => {
+            saveTargetWorkspaceToConfig(params.workspace.id);
+        },
+        setWorkspaces: assign({
+            workspaces: (_, params) => params.output,
+        }),
+        setWorkspace: assign({
+            workspace: (_, params) => params.output,
+        }),
         setSuccess: assign({
             jsContents: (_, params) => params.contents,
             lastSuccessfulJavaScriptBuild: (_, params) => params.time,
@@ -610,8 +641,9 @@ export const devMachine = setup({
         "Read Config": {
             on: {
                 "Initialized": {
-                    target: "Watching",
+                    target: "Choose Target Workspace",
                     actions: { type: "setConfig", params: ({ event }) => event },
+                    reenter: true,
                 },
                 "Initialization Error": {
                     target: "No Config",
@@ -632,15 +664,175 @@ export const devMachine = setup({
         "Auth Error": {
             type: "final",
         },
-        "Generic Error": {
+        "Choose Target Workspace": {
+            states: {
+                "Need Target Workspace?": {
+                    always: [
+                        {
+                            target: "#Dev Machine.Loading Workspace Details",
+                            guard: { type: "have target workspace", params: ({ context }) => context },
+                            reenter: true,
+                        },
+                        "Loading Workspaces",
+                    ],
+                },
+                "Loading Workspaces": {
+                    invoke: {
+                        src: "loadWorkspaces",
+                        input: ({ context }) => ({ token: context.config.token }),
+                        onDone: [
+                            {
+                                target: "#Dev Machine.Loading Workspace Details",
+                                guard: {
+                                    type: "only one workspace and admin",
+                                    params: ({ event }) => event,
+                                },
+                                reenter: true,
+                                actions: [
+                                    {
+                                        type: "setTargetWorkspace",
+                                        params: ({ context, event }) => ({
+                                            config: context.config,
+                                            workspace: event.output[0],
+                                        }),
+                                    },
+                                    {
+                                        type: "saveTargetWorkspaceToConfig",
+                                        params: ({ event }) => ({ workspace: event.output[0] }),
+                                    },
+                                ],
+                            },
+                            {
+                                target: "#Dev Machine.Not admin of only workspace",
+                                guard: {
+                                    type: "only one workspace and not admin",
+                                    params: ({ event }) => event,
+                                },
+                                reenter: true,
+                                actions: {
+                                    type: "printError",
+                                    params: ({ event }) => ({
+                                        error: `You are not the admin of the workspace ${event.output[0].name}. Please ask an admin to make you an admin of the workspace or create your own workspace.
+
+${APP}/welcome/workspace-details
+                                      `,
+                                    }),
+                                },
+                            },
+                            {
+                                target: "Ask for Workspace",
+                                guard: { type: "have workspaces", params: ({ event }) => event },
+                                actions: { type: "setWorkspaces", params: ({ event }) => event },
+                            },
+                            {
+                                target: "No Workspaces",
+                                reenter: true,
+                                actions: {
+                                    type: "printError",
+                                    params: () => ({
+                                        error: `You are not the admin of any workspaces. Either request permission from an existing workspace or create your own.
+
+${APP}/welcome/workspace-details
+                                      `,
+                                    }),
+                                },
+                            },
+                        ],
+                        onError: {
+                            target: "Failed to load workspaces",
+                            actions: {
+                                type: "printError",
+                                params: ({ event }) => ({
+                                    error: `Failed to load workspaces: ${event.error}`,
+                                }),
+                            },
+                        },
+                    },
+                },
+                "Ask for Workspace": {
+                    invoke: {
+                        src: "askForWorkspace",
+                        input: ({ context }) => ({
+                            message: "Choose a workspace",
+                            choices: context.workspaces.map((workspace) => ({
+                                name: workspace.name,
+                                value: workspace,
+                            })),
+                        }),
+                        onDone: [
+                            {
+                                target: "#Dev Machine.Loading Workspace Details",
+                                actions: [
+                                    {
+                                        type: "setTargetWorkspace",
+                                        params: ({ context, event }) => ({
+                                            config: context.config,
+                                            workspace: event.output,
+                                        }),
+                                    },
+                                    {
+                                        type: "saveTargetWorkspaceToConfig",
+                                        params: ({ event }) => ({ workspace: event.output }),
+                                    },
+                                ],
+                                guard: { type: "is workspace admin", params: ({ event }) => event },
+                                reenter: true,
+                            },
+                            {
+                                target: "#Dev Machine.Require Admin Workspace",
+                                reenter: true,
+                                actions: {
+                                    type: "printError",
+                                    params: ({ event }) => ({
+                                        error: `You are not the admin of the workspace ${event.output.name}. Please ask an admin to make you an admin of the workspace or create your own workspace.
+
+${APP}/welcome/workspace-details
+                                      `,
+                                    }),
+                                },
+                            },
+                        ],
+                    },
+                },
+                "No Workspaces": {
+                    type: "final",
+                },
+                "Failed to load workspaces": {
+                    type: "final",
+                },
+            },
+            initial: "Need Target Workspace?",
+        },
+        "Require Admin Workspace": {
+            type: "final",
+        },
+        "Not admin of only workspace": {
             type: "final",
         },
-    },
-    entry: "printLogo",
-    on: {
-        Error: {
-            target: ".Generic Error",
-            actions: { type: "printGenericError", params: ({ event }) => event },
+        "Loading Workspace Details": {
+            invoke: {
+                src: "loadWorkspaceDetails",
+                input: ({ context }) => ({
+                    config: context.config,
+                }),
+                onDone: {
+                    target: "Watching",
+                    actions: { type: "setWorkspace", params: ({ event }) => event },
+                },
+                onError: {
+                    target: "Failed to load workspaces",
+                    actions: {
+                        type: "printError",
+                        params: () => ({
+                            error: "Failed to load workspace details",
+                        }),
+                    },
+                },
+            },
+        },
+        "Failed to load workspaces": {
+            type: "final",
         },
     },
+    entry: "printLogo",
 });

package/lib/machines/init-machine.js

@@ -86,13 +86,18 @@ export const initMachine = setup({
         loadAppInfo: fromPromise(async ({ input: { token, developerSlug, appSlug } }) => {
             const spinner = new Spinner();
             spinner.start("Loading app information...");
-            const appInfo = await getAppInfo({ token, developerSlug, appSlug });
-            if (appInfo === null) {
-                spinner.error("App not found");
-                return null;
+            try {
+                const appInfo = await getAppInfo({ token, developerSlug, appSlug });
+                if (appInfo === null) {
+                    spinner.error("App not found");
+                    return null;
+                }
+                spinner.success(`App found: ${appInfo.title}`);
+                return appInfo;
+            }
+            finally {
+                spinner.stop();
             }
-            spinner.success(`App found: ${appInfo.title}`);
-            return appInfo;
         }),
     },
     actions: {

package/lib/templates/javascript/src/cat-fact.jsx

@@ -0,0 +1,16 @@
+import React from "react"
+import {TextBlock, useAsyncCache} from "attio/client"
+import getCatFact from "./get-cat-fact.server"
+
+export function CatFact({recordId}) {
+  // By passing in the recordId, the result will be cached for each recordId
+  const {
+    values: {catFact},
+    //       ^^^^^^^– this key matches
+    //               vvvvvvv– this key
+  } = useAsyncCache({catFact: [getCatFact, recordId]})
+  //                           ^^^^^^^^^^  ^^^^^^^^
+  //                           async fn    parameter(s)
+
+  return <TextBlock align="center">{`"${catFact}"`}</TextBlock>
+}

package/lib/templates/javascript/src/get-cat-fact.server.js

@@ -0,0 +1,6 @@
+export default async function getCatFact(recordId) {
+    // We don't really need the recordId for this API, but this is how we could use a parameter
+    const response = await fetch(`https://catfact.ninja/fact?${recordId}`)
+    const data = await response.json()
+    return data.fact
+}

package/lib/templates/javascript/src/hello-world-dialog.jsx

@@ -1,10 +1,11 @@
 import React from "react"
 import {TextBlock} from "attio/client"
-import {Advice} from "./advice"
+import {CatFact} from "./cat-fact"
 
-const Loading = () => <TextBlock>Loading advice...</TextBlock>
+const Loading = () => <TextBlock>Loading cat fact...</TextBlock>
 
-export function HelloWorldDialog ({recordId}) {
+export function HelloWorldDialog({recordId}) {
+    // A simple counter to demonstrate that this is just regular React code.
     const [seconds, setSeconds] = React.useState(0)
     React.useEffect(() => {
         const timeout = setTimeout(() => setSeconds(seconds + 1), 1000)
@@ -16,9 +17,9 @@ export function HelloWorldDialog ({recordId}) {
             <TextBlock align="left">
                 I am a dialog. I have been open for: {seconds} second{seconds === 1 ? "" : "s"}
             </TextBlock>
-            {/* The hook in Advice will suspend until the advice is loaded. */}
+            {/* The hook in CatFact will suspend until the cat fact is loaded. */}
             <React.Suspense fallback={<Loading />}>
-                <Advice recordId={recordId} />
+                <CatFact recordId={recordId} />
             </React.Suspense>
         </>
     )

package/lib/templates/typescript/src/cat-fact.tsx

@@ -0,0 +1,16 @@
+import React from "react"
+import {TextBlock, useAsyncCache} from "attio/client"
+import getCatFact from "./get-cat-fact.server"
+
+export function CatFact({recordId}: {recordId: string}) {
+    // By passing in the recordId, the result will be cached for each recordId
+    const {
+        values: {catFact},
+        //       ^^^^^^^– this key matches
+        //               vvvvvvv– this key
+    } = useAsyncCache({catFact: [getCatFact, recordId]})
+    //                           ^^^^^^^^^^  ^^^^^^^^
+    //                           async fn    parameter(s)
+
+    return <TextBlock align="center">{`"${catFact}"`}</TextBlock>
+}

package/lib/templates/typescript/src/get-cat-fact.server.ts

@@ -0,0 +1,6 @@
+export default async function getCatFact(recordId: string): Promise<string> {
+    // We don't really need the recordId for this API, but this is how we could use a parameter
+    const response = await fetch(`https://catfact.ninja/fact?${recordId}`)
+    const data = await response.json()
+    return data.fact
+}

package/lib/templates/typescript/src/hello-world-dialog.tsx

@@ -1,10 +1,11 @@
 import React from "react"
 import {TextBlock} from "attio/client"
-import {Advice} from "./advice"
+import {CatFact} from "./cat-fact"
 
-const Loading = () => <TextBlock>Loading advice...</TextBlock>
+const Loading = () => <TextBlock>Loading cat fact...</TextBlock>
 
 export function HelloWorldDialog({recordId}: {recordId: string}) {
+    // A simple counter to demonstrate that this is just regular React code.
     const [seconds, setSeconds] = React.useState(0)
     React.useEffect(() => {
         const timeout = setTimeout(() => setSeconds(seconds + 1), 1000)
@@ -16,9 +17,9 @@ export function HelloWorldDialog({recordId}: {recordId: string}) {
             <TextBlock align="left">
                 I am a dialog. I have been open for: {seconds} second{seconds === 1 ? "" : "s"}
             </TextBlock>
-            {/* The hook in Advice will suspend until the advice is loaded. */}
+            {/* The hook in CatFact will suspend until the cat fact is loaded. */}
             <React.Suspense fallback={<Loading />}>
-                <Advice recordId={recordId} />
+                <CatFact recordId={recordId} />
             </React.Suspense>
         </>
     )

package/lib/util/load-developer-config.js

@@ -7,7 +7,7 @@ import { isValidSlug } from "./validate-slug.js";
 export const initialDeveloperConfigSchema = z.object({
     token: z.string(),
     developer_slug: z.string(),
-    target_workspace_id: z.string().uuid(),
+    target_workspace_id: z.string().uuid().optional().nullable(),
 });
 const developerConfigSchema = initialDeveloperConfigSchema.extend({
     developer_account_id: z.string(),
@@ -76,8 +76,16 @@ export async function loadDeveloperConfig() {
         developer_slug: developerSlug,
         developer_account_id: devAccount.developer_account.developer_account_id,
         developer_account_member_id: devAccount.developer_account_member.developer_account_member_id,
-        target_workspace_id: initialDeveloperConfig.target_workspace_id,
+        target_workspace_id: initialDeveloperConfig.target_workspace_id ?? null,
     });
     writeFileSync(configFile.path, stringify(config));
     return config;
 }
+export async function saveTargetWorkspaceToConfig(workspaceId) {
+    const configFile = readDeveloperConfigFile();
+    if (configFile === "No config file" || configFile === "Invalid config file")
+        return;
+    const config = developerConfigSchema.parse(configFile.contents);
+    config.target_workspace_id = workspaceId;
+    writeFileSync(configFile.path, stringify(config));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "attio",
-  "version": "0.0.1-experimental.20250303",
+  "version": "0.0.1-experimental.20250321",
   "bin": "lib/attio.js",
   "type": "module",
   "files": [

package/lib/api/publish-version.js

@@ -1,15 +0,0 @@
-import { z } from "zod";
-import { API } from "../env.js";
-import { handleError } from "./handle-error.js";
-import { makeHeaders } from "./make-headers.js";
-const publishVersionSchema = z.object({
-    success: z.literal(true),
-});
-export async function publishVersion({ token, devSlug, appId, major, minor, }) {
-    const response = await fetch(`${API}/developer-accounts/${devSlug}/apps/${appId}/prod-versions/${major}/${minor}/publish`, {
-        method: "POST",
-        headers: makeHeaders(token),
-    });
-    await handleError(response);
-    return publishVersionSchema.parse(await response.json());
-}

package/lib/commands/connection/add.js

@@ -1,67 +0,0 @@
-import { Command, Option } from "commander";
-import { createActor } from "xstate";
-import { z } from "zod";
-import { addConnectionMachine } from "../../machines/add-connection-machine.js";
-export const optionsSchema = z.object({
-    label: z.string().optional(),
-    description: z.string().optional(),
-    type: z.enum(["secret", "oauth2-code"]).optional(),
-    authorizeUrl: z
-        .string()
-        .url("Invalid URL, e.g. https://authorization-server.com/authorize")
-        .startsWith("https://", { message: "Must provide secure authorize URL (https://...)" })
-        .optional(),
-    accessTokenUrl: z
-        .string()
-        .url("Invalid URL, e.g. https://authorization-server.com/token")
-        .startsWith("https://", { message: "Must provide secure access token URL (https://...)" })
-        .optional(),
-    scopes: z
-        .string()
-        .refine((value) => value.split(",").every((scope) => scope.trim().length > 0), {
-        message: "Invalid OAuth scopes format. Must be a comma-delimited list of non-empty strings.",
-    })
-        .optional(),
-    clientId: z.string().optional(),
-    clientSecret: z.string().optional(),
-    dev: z.boolean().default(false),
-});
-export const connectionAdd = new Command("add")
-    .description("Create a new connection for your Attio app")
-    .addOption(new Option("--label", "The label for your connection that will be displayed to users"))
-    .addOption(new Option("--description", "A more detailed description of your connection that will be displayed to users"))
-    .addOption(new Option("--type <type>", "The type of connection to create").choices([
-    "secret",
-    "oauth2-code",
-]))
-    .addOption(new Option("--authorize-url <url>", "The authorize URL for OAuth connection"))
-    .addOption(new Option("--access-token-url <url>", "The access token URL for OAuth connection"))
-    .addOption(new Option("--scopes <scopes>", "A comma separated list of scopes for OAuth connection"))
-    .addOption(new Option("--client-id <id>", "The client ID for OAuth connection"))
-    .addOption(new Option("--client-secret <secret>", "The client secret for OAuth connection"))
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedOptions) => {
-    let options;
-    try {
-        options = optionsSchema.parse(unparsedOptions);
-    }
-    catch (error) {
-        if (error instanceof z.ZodError) {
-            process.stderr.write("\nInvalid options:\n");
-            error.errors.forEach((err) => {
-                process.stderr.write(`- ${err.path.map((p) => String(p).replace(/[A-Z]/g, (m) => `-${m.toLowerCase()}`)).join(".")}: ${err.message}\n`);
-            });
-            process.exit(1);
-        }
-        throw error;
-    }
-    const actor = createActor(addConnectionMachine, {
-        input: options,
-    });
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
-        });
-    }
-    actor.start();
-});

package/lib/commands/connection/index.js

@@ -1,9 +0,0 @@
-import { Command } from "commander";
-import { connectionAdd } from "./add.js";
-import { connectionList } from "./list.js";
-import { connectionRemove } from "./remove.js";
-export const connection = new Command("connection")
-    .description("Manage app connections")
-    .addCommand(connectionAdd)
-    .addCommand(connectionList)
-    .addCommand(connectionRemove);

package/lib/commands/connection/list.js

@@ -1,20 +0,0 @@
-import { Command, Option } from "commander";
-import { createActor } from "xstate";
-import { z } from "zod";
-import { listConnectionsMachine } from "../../machines/list-connections-machine.js";
-export const optionsSchema = z.object({
-    dev: z.boolean().default(false),
-});
-export const connectionList = new Command("list")
-    .description("List all connections for the current major version of your Attio app")
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedOptions) => {
-    const options = optionsSchema.parse(unparsedOptions);
-    const actor = createActor(listConnectionsMachine);
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
-        });
-    }
-    actor.start();
-});

package/lib/commands/connection/remove.js

@@ -1,20 +0,0 @@
-import { Command, Option } from "commander";
-import { createActor } from "xstate";
-import { z } from "zod";
-import { removeConnectionMachine } from "../../machines/remove-connection-machine.js";
-export const optionsSchema = z.object({
-    dev: z.boolean().default(false),
-});
-export const connectionRemove = new Command("remove")
-    .description("Remove a connection from your Attio app")
-    .addOption(new Option("--dev", "Run in development mode (additional debugging info)"))
-    .action((unparsedOptions) => {
-    const options = optionsSchema.parse(unparsedOptions);
-    const actor = createActor(removeConnectionMachine);
-    if (options.dev) {
-        actor.subscribe((state) => {
-            console.log("state:", state.value);
-        });
-    }
-    actor.start();
-});