@netnodeag/kraftwerk 0.47.0 → 0.49.0

package/dist/dotenv.d.ts

@@ -0,0 +1,40 @@
+/**
+ * The project's `.env`: KEY=VALUE lines next to kraftwerk.yml, loaded into
+ * this process at CLI start (a commander preAction hook in kraftwerk.ts),
+ * so every kraftwerk process sees them and everything it spawns inherits
+ * them — the inspector, the chat agents and routines, workflow runs, the
+ * tunnel (TUNNEL_TOKEN), `requires:` checks.
+ *
+ * A variable already set in the shell wins over the file, the dotenv
+ * convention, with one exception that makes restarts work: a value this
+ * process inherited from an earlier kraftwerk process that itself took it
+ * from a `.env` is not a shell setting. Those keys are listed in
+ * KRAFTWERK_DOTENV_KEYS by whoever injected them, so a restarted server
+ * (the `kraftwerk ui` supervisor respawns it with its own environment)
+ * re-reads the file and applies changed values, and a project launched
+ * from another workspace's inspector drops that workspace's variables
+ * instead of running with them.
+ *
+ * Never synced: `.env` is on the workspace git's deny list (git.ts) and in
+ * the .gitignore `kraftwerk init` writes.
+ */
+export declare const DOTENV_FILE = ".env";
+export declare const DOTENV_MARKER = "KRAFTWERK_DOTENV_KEYS";
+/** Parse dotenv text: comments, `export ` prefixes, single/double quotes, `\n` in double quotes. */
+export declare function parseDotenv(text: string): Record<string, string>;
+export interface DotenvResult {
+    /** Absolute path of the file, undefined when the project has none. */
+    file?: string;
+    /** Keys set from the file. */
+    applied: string[];
+    /** Keys in the file left alone because the shell had set them. */
+    kept: string[];
+    /** Keys an earlier kraftwerk process had injected that this file no longer has. */
+    removed: string[];
+}
+/**
+ * Apply `<root>/.env` to process.env (see the module comment for the
+ * precedence). Idempotent: a second call re-applies the same keys. Without
+ * a file it still drops keys an earlier process injected.
+ */
+export declare function applyDotenv(root: string): Promise<DotenvResult>;

package/dist/dotenv.js

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+/**
+ * The project's `.env`: KEY=VALUE lines next to kraftwerk.yml, loaded into
+ * this process at CLI start (a commander preAction hook in kraftwerk.ts),
+ * so every kraftwerk process sees them and everything it spawns inherits
+ * them — the inspector, the chat agents and routines, workflow runs, the
+ * tunnel (TUNNEL_TOKEN), `requires:` checks.
+ *
+ * A variable already set in the shell wins over the file, the dotenv
+ * convention, with one exception that makes restarts work: a value this
+ * process inherited from an earlier kraftwerk process that itself took it
+ * from a `.env` is not a shell setting. Those keys are listed in
+ * KRAFTWERK_DOTENV_KEYS by whoever injected them, so a restarted server
+ * (the `kraftwerk ui` supervisor respawns it with its own environment)
+ * re-reads the file and applies changed values, and a project launched
+ * from another workspace's inspector drops that workspace's variables
+ * instead of running with them.
+ *
+ * Never synced: `.env` is on the workspace git's deny list (git.ts) and in
+ * the .gitignore `kraftwerk init` writes.
+ */
+export const DOTENV_FILE = ".env";
+export const DOTENV_MARKER = "KRAFTWERK_DOTENV_KEYS";
+const KEY = /^[A-Za-z_][A-Za-z0-9_]*$/;
+/** Parse dotenv text: comments, `export ` prefixes, single/double quotes, `\n` in double quotes. */
+export function parseDotenv(text) {
+    const out = {};
+    for (const raw of text.split(/\r?\n/)) {
+        const line = raw.trim();
+        if (!line || line.startsWith("#"))
+            continue;
+        const eq = line.indexOf("=");
+        if (eq < 0)
+            continue;
+        const key = line.slice(0, eq).trim().replace(/^export\s+/, "");
+        if (!KEY.test(key))
+            continue;
+        let value = line.slice(eq + 1).trim();
+        if (value.startsWith('"') && value.endsWith('"') && value.length >= 2) {
+            value = value.slice(1, -1).replace(/\\n/g, "\n").replace(/\\t/g, "\t").replace(/\\"/g, '"').replace(/\\\\/g, "\\");
+        }
+        else if (value.startsWith("'") && value.endsWith("'") && value.length >= 2) {
+            value = value.slice(1, -1);
+        }
+        else {
+            // An unquoted value ends at a comment: `PORT=1981 # inspector`.
+            value = value.replace(/\s+#.*$/, "").trim();
+        }
+        out[key] = value;
+    }
+    return out;
+}
+/**
+ * Apply `<root>/.env` to process.env (see the module comment for the
+ * precedence). Idempotent: a second call re-applies the same keys. Without
+ * a file it still drops keys an earlier process injected.
+ */
+export async function applyDotenv(root) {
+    const file = path.join(root, DOTENV_FILE);
+    const text = await readFile(file, "utf8").catch(() => undefined);
+    const parsed = text === undefined ? {} : parseDotenv(text);
+    const injected = new Set((process.env[DOTENV_MARKER] ?? "").split(",").filter(Boolean));
+    const applied = [];
+    const kept = [];
+    for (const [key, value] of Object.entries(parsed)) {
+        // An empty shell value is as good as unset (`requires:` treats it so too).
+        if (!process.env[key] || injected.has(key)) {
+            process.env[key] = value;
+            applied.push(key);
+        }
+        else {
+            kept.push(key);
+        }
+    }
+    const removed = [...injected].filter((key) => !(key in parsed));
+    for (const key of removed)
+        delete process.env[key];
+    if (applied.length > 0)
+        process.env[DOTENV_MARKER] = applied.join(",");
+    else
+        delete process.env[DOTENV_MARKER];
+    return { file: text === undefined ? undefined : file, applied, kept, removed };
+}

package/dist/inspector/agents.js

@@ -3,7 +3,7 @@ import path from "node:path";
 import { parse, stringify } from "yaml";
 import { resolveProject } from "../config.js";
 import { getProjectRoot } from "./context.js";
-import { syncProjectAgents } from "./instances.js";
+import { syncWorkspaceAgents } from "./instances.js";
 /**
  * Agents: persistent agents, defined on the filesystem. Each one
  * is one folder under the project's agents/ root:
@@ -88,7 +88,7 @@ export async function listAgents() {
     // palettes. Awaited so a read that follows a save sees the record updated;
     // it only writes when the roster changed.
     await resolveProject(getProjectRoot())
-        .then((p) => syncProjectAgents(p.root, list.filter((a) => !a.archived).map(toSummary)))
+        .then((p) => syncWorkspaceAgents(p.root, list.filter((a) => !a.archived).map(toSummary)))
         .catch(() => { });
     return list;
 }

package/dist/inspector/channels.d.ts

@@ -3,7 +3,7 @@
  * channel where the coworkers are agents. The definition is git-tracked
  * with the workspace so the whole team sees the same channels:
  *
- *   channels/<slug>/channel.yml   # name, purpose, members (agent slugs), responder, maxHops
+ *   channels/<slug>/channel.yml   # name, purpose, members (agent slugs), responder, maxHops, project
  *
  * The transcript itself is a chat (scope { kind: "channel", slug }) under
  * <output>/chats/, run-state like every other chat. sessions.ts gives each
@@ -22,6 +22,13 @@ export interface Channel {
     responder?: string;
     /** Agent-to-agent handovers allowed per human message. */
     maxHops: number;
+    /**
+     * The project this channel works in (a slug under the projects root):
+     * every member gets the project's brief, state, records and links as
+     * context, and the channel lists under the project. Set when a project
+     * chat gets its first coworker; see convertChatToChannel.
+     */
+    project?: string;
 }
 /** What the ⌘K palette needs of a channel (and what the project registry records). */
 export type ChannelSummary = Pick<Channel, "slug" | "name" | "purpose">;
@@ -39,6 +46,8 @@ export interface SaveChannelInput {
     /** Agent slug, or "" / null to clear. */
     responder?: string | null;
     maxHops?: number;
+    /** Project slug, or "" / null to detach. */
+    project?: string | null;
 }
 /** Create (no slug: derived from the name) or update a channel definition. */
 export declare function saveChannel(input: SaveChannelInput): Promise<Channel>;

package/dist/inspector/channels.js

@@ -4,7 +4,7 @@ import { parse, stringify } from "yaml";
 import { getProjectRoot } from "./context.js";
 import { resolveProject } from "../config.js";
 import { listAgents, safeAgentSlug, slugFromName } from "./agents.js";
-import { syncProjectChannels } from "./instances.js";
+import { syncWorkspaceChannels } from "./instances.js";
 export const toChannelSummary = (c) => ({
     slug: c.slug,
     name: c.name,
@@ -21,6 +21,7 @@ export function safeChannelSlug(slug) {
         throw new Error(`invalid channel slug "${slug}"`);
     return slug;
 }
+const PROJECT_SLUG_RE = /^[a-z0-9][a-z0-9-]{0,48}$/;
 function normalize(slug, raw) {
     const members = Array.isArray(raw.members) ? [...new Set(raw.members.map(String))] : [];
     const responder = typeof raw.responder === "string" && members.includes(raw.responder) ? raw.responder : undefined;
@@ -32,6 +33,7 @@ function normalize(slug, raw) {
         members,
         ...(responder ? { responder } : {}),
         maxHops: hops,
+        ...(typeof raw.project === "string" && PROJECT_SLUG_RE.test(raw.project) ? { project: raw.project } : {}),
     };
 }
 export async function listChannels() {
@@ -49,7 +51,7 @@ export async function listChannels() {
     const list = channels.filter(Boolean).sort((a, b) => a.name.localeCompare(b.name));
     // Like the agent roster: the registry copy feeds other instances' palettes.
     await resolveProject(getProjectRoot())
-        .then((p) => syncProjectChannels(p.root, list.map(toChannelSummary)))
+        .then((p) => syncWorkspaceChannels(p.root, list.map(toChannelSummary)))
         .catch(() => { });
     return list;
 }
@@ -100,6 +102,12 @@ export async function saveChannel(input) {
                 throw new Error("maxHops must be a whole number");
             })()
         : existing?.maxHops ?? DEFAULT_MAX_HOPS;
+    let project = existing?.project;
+    if (input.project !== undefined) {
+        if (input.project && !PROJECT_SLUG_RE.test(input.project))
+            throw new Error(`invalid project name "${input.project}"`);
+        project = input.project || undefined;
+    }
     const channel = {
         slug,
         name,
@@ -113,6 +121,7 @@ export async function saveChannel(input) {
         members,
         ...(responder ? { responder } : {}),
         maxHops,
+        ...(project ? { project } : {}),
     };
     const dir = path.join(await channelsRoot(), slug);
     await fs.mkdir(dir, { recursive: true });

package/dist/inspector/chat/sessions.d.ts

@@ -44,9 +44,14 @@ export declare function postMessage(id: string, text: string, opts?: {
 /** The chat that holds a channel's transcript; created on first use. */
 export declare function ensureChannelChat(channel: Channel): Promise<ChatMeta>;
 /**
- * "Add a coworker" to an agent session: the chat becomes the channel's
- * transcript. The agent keeps its process and memory — it has seen every
- * message so far — and learns the channel rules with its next prompt.
+ * "Add a coworker": the chat becomes the channel's transcript.
+ *
+ * From an agent session, the agent keeps its process and memory — it has
+ * seen every message so far — and learns the channel rules with its next
+ * prompt. From a project chat, the project assistant has no agent identity
+ * to keep, so its process goes; the members join with the whole transcript
+ * (a fresh seat starts at seq 0) and the project's context, and the chat
+ * stays listed under the project through meta.project.
  */
 export declare function convertChatToChannel(chatId: string, channel: Channel): Promise<{
     error?: string;

package/dist/inspector/chat/sessions.js

@@ -8,6 +8,7 @@ import { listWorkflows } from "../workflows.js";
 import { getAgent, listAgents } from "../agents.js";
 import { listRepos } from "../repos.js";
 import { resolveVibeable, vibeableStatus, VIBEABLE_CONFIG_FILE } from "../vibeables.js";
+import { getProject, projectContext } from "../projects.js";
 import { deleteAgentSession, listAgentSessions, startAcpBackend } from "./acp.js";
 import { startPiBackend } from "./pi.js";
 import { UNATTENDED_PERMISSION_TIMEOUT_MS, declineOption, unattendedTimeoutLabel } from "./permissions.js";
@@ -401,6 +402,11 @@ async function baseScopeContext(scope, agent) {
                     `not retry it another way. End with a clear, self-contained summary of what you did and found.`
                 : ""));
     }
+    if (scope.kind === "project") {
+        // Everything the project gathered — brief, state, records, links — plus
+        // how to keep it current; see projects.ts for the block.
+        return projectContext(scope.slug, `kraftwerk-chat/${agent}`);
+    }
     if (scope.kind === "knowledge") {
         const { root, bundles } = await knowledgeIndex().catch(() => ({ root: "", bundles: [] }));
         const bundleLines = bundles
@@ -502,14 +508,16 @@ async function scopeContext(meta, seat) {
     const agent = seat.harness;
     // The repositories block reads every clone from git, so it runs alongside
     // the rest instead of adding its spawns to the first prompt's latency.
-    const [base, repos, vibe, skills, channel] = await Promise.all([
+    const [base, repos, vibe, skills, channel, project] = await Promise.all([
         baseScopeContext(scope, agent),
         scope.kind === "agent" || scope.kind === "kraftwerk" ? reposContext() : Promise.resolve(""),
         meta.vibeable ? vibeableContext(meta.vibeable, meta.cwd) : Promise.resolve(""),
         availableSkills(scope),
         meta.scope.kind === "channel" ? channelContext(meta.scope.slug, seat.key) : Promise.resolve(""),
+        // A channel that works in a project: every member reads the project too, as a member, not as its assistant.
+        meta.scope.kind === "channel" && meta.project ? projectContext(meta.project, `${seat.key}/${agent}`, { member: true }) : Promise.resolve(""),
     ]);
-    return [base, channel, repos, vibe, RENDERING_BLOCK, skillsBlock(skills)].filter(Boolean).join("\n\n");
+    return [base, channel, project, repos, vibe, RENDERING_BLOCK, skillsBlock(skills)].filter(Boolean).join("\n\n");
 }
 /** The channel block a member agent gets once per process: who is here, how turns work, how to hand over. */
 async function channelContext(slug, self) {
@@ -554,6 +562,14 @@ async function backendTuning(meta, seat) {
         if (agent === "claude" && def?.skills)
             tuning.skills = def.skills;
     }
+    // Project chats carry the project's model/effort the same way.
+    if (scope.kind === "project") {
+        const def = await getProject(scope.slug).catch(() => null);
+        if (def?.model)
+            tuning.model = def.model;
+        if (def?.effort)
+            tuning.effort = def.effort;
+    }
     // Run chats live in the run folder — grant claude the project root so
     // project-level skills and files stay reachable.
     // A vibeable session works inside the app folder for the same reason.
@@ -944,34 +960,57 @@ export async function ensureChannelChat(channel) {
     const existing = metas.find((m) => m.scope.kind === "channel" && m.scope.slug === channel.slug);
     if (existing)
         return states.get(existing.id)?.meta ?? existing;
-    return createChat({ agent: "claude", scope: { kind: "channel", slug: channel.slug }, title: channel.name });
+    const meta = await createChat({ agent: "claude", scope: { kind: "channel", slug: channel.slug }, title: channel.name });
+    if (channel.project) {
+        meta.project = channel.project;
+        await writeMeta(meta);
+    }
+    return meta;
 }
 /**
- * "Add a coworker" to an agent session: the chat becomes the channel's
- * transcript. The agent keeps its process and memory — it has seen every
- * message so far — and learns the channel rules with its next prompt.
+ * "Add a coworker": the chat becomes the channel's transcript.
+ *
+ * From an agent session, the agent keeps its process and memory — it has
+ * seen every message so far — and learns the channel rules with its next
+ * prompt. From a project chat, the project assistant has no agent identity
+ * to keep, so its process goes; the members join with the whole transcript
+ * (a fresh seat starts at seq 0) and the project's context, and the chat
+ * stays listed under the project through meta.project.
  */
 export async function convertChatToChannel(chatId, channel) {
     const state = await loadState(chatId);
     if (!state)
         return { error: "chat not found" };
     const scope = state.meta.scope;
-    if (scope.kind !== "agent")
-        return { error: "only an agent session can become a channel" };
-    if (!channel.members.includes(scope.slug))
+    if (scope.kind !== "agent" && scope.kind !== "project")
+        return { error: "only an agent session or a project chat can become a channel" };
+    if (scope.kind === "agent" && !channel.members.includes(scope.slug))
         return { error: `the channel must include @${scope.slug}` };
     if (isBusy(state))
         return { error: "agent is still working — wait for the turn to finish" };
-    const main = state.seats.get(MAIN);
-    state.seats.delete(MAIN);
-    const seat = main ?? newSeat(scope.slug, state.meta.agent);
-    seat.key = scope.slug;
-    seat.needsContext = true;
-    seat.seenSeq = state.events[state.events.length - 1]?.seq ?? 0;
-    state.seats.set(scope.slug, seat);
-    if (state.meta.sessions?.[MAIN]) {
-        const { [MAIN]: session, ...rest } = state.meta.sessions;
-        state.meta.sessions = { ...rest, [scope.slug]: session };
+    if (scope.kind === "project") {
+        if (channel.project !== scope.slug)
+            return { error: `the channel must belong to project "${scope.slug}"` };
+        dropBackend(state);
+        state.seats.delete(MAIN);
+        if (state.meta.sessions?.[MAIN]) {
+            const { [MAIN]: _gone, ...rest } = state.meta.sessions;
+            state.meta.sessions = rest;
+        }
+        state.meta.project = scope.slug;
+    }
+    else {
+        const main = state.seats.get(MAIN);
+        state.seats.delete(MAIN);
+        const seat = main ?? newSeat(scope.slug, state.meta.agent);
+        seat.key = scope.slug;
+        seat.needsContext = true;
+        seat.seenSeq = state.events[state.events.length - 1]?.seq ?? 0;
+        state.seats.set(scope.slug, seat);
+        if (state.meta.sessions?.[MAIN]) {
+            const { [MAIN]: session, ...rest } = state.meta.sessions;
+            state.meta.sessions = { ...rest, [scope.slug]: session };
+        }
     }
     state.meta.scope = { kind: "channel", slug: channel.slug };
     state.meta.title = channel.name;

package/dist/inspector/chat/types.d.ts

@@ -21,6 +21,11 @@ export type ChatScope = {
     slug: string;
     routine?: string;
 }
+/** A project: the chat carries its brief, state, systems of record and links; see projects.ts. */
+ | {
+    kind: "project";
+    slug: string;
+}
 /** A channel: several agents (and humans) share one transcript; see channels.ts. */
  | {
     kind: "channel";
@@ -42,6 +47,12 @@ export interface ChatMeta {
     scope: ChatScope;
     /** Slug of the vibeable open in this chat's preview pane (cwd is its folder while set). */
     vibeable?: string;
+    /**
+     * The project this chat belongs to when its scope is not the project
+     * itself: a channel that started as a project chat. Lists the chat under
+     * the project and hands every seat the project's context.
+     */
+    project?: string;
     /**
      * The agent's own session id per seat ("main", or the agent slug in a
      * channel): after a restart or the idle reaper, the next backend resumes

package/dist/inspector/git.js

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
 import path from "node:path";
-import { reposRootFor, resolveProject, vibeablesRootFor, isSafeGitName } from "../config.js";
+import { projectsRootFor, reposRootFor, resolveProject, vibeablesRootFor, isSafeGitName } from "../config.js";
 import { ENV_FILE } from "../runner/docker.js";
 import { getOutputDir, getProjectRoot } from "./context.js";
 /**
@@ -203,7 +203,7 @@ async function checkedOut(repo) {
 }
 /**
  * The roots that may be committed, as repo-relative paths: the workflows,
- * knowledge, agents, skills, channels and vibeables roots this project
+ * knowledge, agents, skills, channels, vibeables and projects roots this project
  * declares, plus kraftwerk.yml and the project README. The output directory
  * is excluded even when it lives inside one of them.
  */
@@ -234,6 +234,8 @@ function scopeFor({ project, repoRoot }) {
         path.resolve(project.root, "channels"),
         // Vibeables are the workspace's own apps: versioned with it, unlike clones.
         vibeablesRootFor(project),
+        // Projects too: briefs, state and logs are the workspace's own record.
+        projectsRootFor(project),
         project.configPath,
         path.resolve(project.root, "README.md"),
     ];
@@ -411,7 +413,7 @@ export async function gitStatus(fresh = false) {
     const blocked = all.filter((f) => !f.syncable).sort(byPath);
     const blockedHidden = Math.max(0, blocked.length - MAX_BLOCKED);
     const scopeError = scope.wholeRepo
-        ? "A configured root points at the repository root, which would put the whole repo in scope. Narrow workflows/knowledge/agents/skills/vibeables in kraftwerk.yml."
+        ? "A configured root points at the repository root, which would put the whole repo in scope. Narrow workflows/knowledge/agents/skills/vibeables/projects in kraftwerk.yml."
         : undefined;
     const value = {
         ...base,

package/dist/inspector/instances.d.ts

@@ -1,7 +1,7 @@
 import type { AgentSummary } from "./agents.js";
 import type { ChannelSummary } from "./channels.js";
 /** Durable per-project record. The root is the key; everything else derives from it. */
-export interface ProjectRecord {
+export interface WorkspaceRecord {
     root: string;
     firstSeen: string;
     lastStarted: string;
@@ -29,7 +29,7 @@ export interface DiscoveredInstance {
 }
 /**
  * One workspace as the switcher shows it: a known project (running or
- * not) or a running instance the projects registry doesn't know yet.
+ * not) or a running instance the workspace registry doesn't know yet.
  */
 export interface WorkspaceEntry {
     name: string;
@@ -49,6 +49,8 @@ export interface WorkspaceEntry {
     lastStarted?: string;
     lastStopped?: string;
 }
+/** File name of a root's record: a hash of the absolute root, the same under the old and the new directory. */
+export declare const workspaceRecordName: (root: string) => string;
 /** ~/… for display. */
 export declare const tildify: (p: string) => string;
 /** Write this instance's registry file (call once the server listens). */
@@ -60,15 +62,15 @@ export declare function unregisterInstance(): void;
 /** All other running instances, verified live. Cached briefly — /api/meta is polled. */
 export declare function discoverInstances(): Promise<DiscoveredInstance[]>;
 /** Upsert the project record for a root (call on every inspector start). */
-export declare function registerProject(root: string): Promise<void>;
-export declare const syncProjectAgents: (root: string, agents: AgentSummary[]) => Promise<void>;
-export declare const syncProjectChannels: (root: string, channels: ChannelSummary[]) => Promise<void>;
+export declare function registerWorkspace(root: string): Promise<void>;
+export declare const syncWorkspaceAgents: (root: string, agents: AgentSummary[]) => Promise<void>;
+export declare const syncWorkspaceChannels: (root: string, channels: ChannelSummary[]) => Promise<void>;
 /** Stamp lastStopped on clean shutdown. Sync so exit handlers can call it. */
-export declare function markProjectStopped(): void;
-/** All known projects, most recently started first. */
-export declare function listProjects(): Promise<ProjectRecord[]>;
-/** Drop a project record (the root itself is untouched). */
-export declare function forgetProject(root: string): Promise<boolean>;
+export declare function markWorkspaceStopped(): void;
+/** All known workspaces, most recently started first. */
+export declare function listWorkspaceRecords(): Promise<WorkspaceRecord[]>;
+/** Drop a workspace record (the root itself is untouched) — from the legacy directory too, see migrateRegistry. */
+export declare function forgetWorkspace(root: string): Promise<boolean>;
 /**
  * The switcher's view: every known project joined with the live instances,
  * plus running instances with no project record yet. The calling instance
@@ -118,14 +120,14 @@ export interface StartResult {
  * Waits up to ~5s for the new inspector to answer so callers can link
  * straight to it.
  */
-export declare function startProject(root: string): Promise<StartResult>;
+export declare function startWorkspace(root: string): Promise<StartResult>;
 /**
  * Stop a running workspace: SIGTERM to its server process, which
  * unregisters, stamps lastStopped and exits; the `kraftwerk ui` supervisor
  * follows. Matched by root, or by url for instances from older versions
  * that registered no root. Waits up to ~5s for the port to go quiet.
  */
-export declare function stopProject(target: {
+export declare function stopWorkspace(target: {
     root?: string;
     url?: string;
 }): Promise<{