@synergenius/flow-weaver 0.33.1 → 0.44.0

package/dist/console/services.d.ts

@@ -0,0 +1,119 @@
+/**
+ * The project's long-lived services, run by the console.
+ *
+ * `fw serve` and `fw watch` run until stopped, which is why the CLI pane
+ * refuses them. Here they are children the console owns: started with the
+ * settings from the Server card, their output kept and streamed, stopped
+ * and restarted from the page, and stopped with the console. A server
+ * someone started from a terminal for the same project is shown beside
+ * them from the service registry, and can be stopped -- it is our process
+ * on our machine -- but not restarted or read, since it is not ours.
+ *
+ * Settings live per project under the user's home, never in the project
+ * tree. A token is generated per start and handed to the child through
+ * the environment. The page shows it because anyone who reaches the
+ * console can already run every workflow.
+ */
+import { type ChildProcess } from 'node:child_process';
+export type ManagedKind = 'serve' | 'watch';
+export interface ServeSettings {
+    port: number;
+    host: string;
+    /** Guard the server with a token generated at start. */
+    auth: 'token' | 'open';
+    agents: boolean;
+    trace: boolean;
+    dev: boolean;
+    swagger: boolean;
+    /** Start it when the console opens. */
+    autoStart: boolean;
+}
+export interface WatchSettings {
+    autoStart: boolean;
+}
+export interface ServiceSettings {
+    serve: ServeSettings;
+    watch: WatchSettings;
+}
+export declare const DEFAULT_SETTINGS: ServiceSettings;
+export interface LogLine {
+    t: number;
+    stream: 'out' | 'err';
+    text: string;
+}
+export type ServiceState = 'stopped' | 'starting' | 'running' | 'exited';
+export interface ServiceView {
+    kind: ManagedKind;
+    state: ServiceState;
+    /** Started by this console, so it can be restarted and read. */
+    owned: boolean;
+    pid?: number;
+    url?: string;
+    startedAt?: string;
+    /** For an exited child: how it ended, and the last thing it said. */
+    exitCode?: number | null;
+    error?: string;
+    /** Kept log lines, for the drawer to know there is something to open. */
+    lines: number;
+    /** The token the running server wants, only for a server this console started. */
+    token?: string;
+    /** What the registry knows: requests answered, the last one, the install. */
+    activity?: {
+        count: number;
+        last?: string;
+        at: string;
+        version: string;
+        install: string;
+    };
+    /** Other processes of this kind for the project, not ours. */
+    others: Array<{
+        pid: number;
+        url?: string;
+        startedAt: string;
+        version: string;
+        install: string;
+    }>;
+}
+export interface SupervisorOptions {
+    projectDir: string;
+    /** Where settings are kept. Default `~/.fw/console`, or `FW_CONSOLE_DIR`. */
+    settingsDir?: string;
+    /** Start a child. A test hands in a fake. */
+    spawn?: (args: string[], cwd: string, env: NodeJS.ProcessEnv) => ChildProcess;
+    /** Called whenever a service changes state or says something. */
+    onChange?: (event: {
+        kind: ManagedKind;
+        state: ServiceState;
+        line?: LogLine;
+        url?: string;
+        exitCode?: number | null;
+        error?: string;
+    }) => void;
+    /** Where the registry is read from. A test points it elsewhere. */
+    registryDir?: string;
+}
+export declare class Supervisor {
+    private readonly opts;
+    private readonly children;
+    private readonly listeners;
+    private readonly file;
+    private cache?;
+    readonly projectDir: string;
+    constructor(opts: SupervisorOptions);
+    settings(): ServiceSettings;
+    saveSettings<K extends ManagedKind>(kind: K, patch: Partial<ServiceSettings[K]>): ServiceSettings;
+    /** Start a service with the saved settings. A running one is left alone. */
+    start(kind: ManagedKind): ServiceView;
+    /** Stop our child of this kind, or another process of this kind for the project by pid. */
+    stop(kind: ManagedKind, pid?: number): Promise<ServiceView>;
+    restart(kind: ManagedKind): Promise<ServiceView>;
+    /** Stop every child; called when the console closes. */
+    close(): Promise<void>;
+    logs(kind: ManagedKind): LogLine[];
+    /** Every new line as it arrives. Returns the unsubscribe. */
+    onLog(kind: ManagedKind, fn: (line: LogLine) => void): () => void;
+    view(kind: ManagedKind): ServiceView;
+    list(): ServiceView[];
+    private registryFor;
+}
+//# sourceMappingURL=services.d.ts.map

package/dist/console/source.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lifting a workflow's own JSDoc and signature out of its file.
+ *
+ * Node types arrive from the parser with a complete `functionText`, but a
+ * workflow does not, so the console reads it from the source itself. The
+ * naive way -- everything up to the first `{` after the name -- cuts a
+ * signature in half the moment a parameter has an inline object type, which
+ * every workflow's `params` does.
+ */
+export interface WorkflowSource {
+    source: string;
+    line: number;
+}
+/**
+ * The workflow's JSDoc block and full signature, up to the opening brace.
+ *
+ * @param text - The file's contents.
+ * @param fnName - The exported workflow function's name.
+ * @returns The source and the 1-based line it starts on. Empty when the
+ *   declaration cannot be found.
+ */
+export declare function workflowSource(text: string, fnName: string): WorkflowSource;
+//# sourceMappingURL=source.d.ts.map

package/dist/console/status.d.ts

@@ -0,0 +1,68 @@
+import { type ServiceRecord } from '../service-registry.js';
+import { type DoctorReport } from '../cli/commands/doctor.js';
+import { type Registry } from '../marketplace/npmrc.js';
+export interface McpRegistration {
+    /** The editor, as `fw mcp-setup` names it. */
+    tool: string;
+    file: string;
+    command: string;
+    args: string[];
+    /** What the registration runs: this install, another one on disk, or whatever npm serves as latest. */
+    runs: 'this install' | 'other install' | 'npm latest' | 'unknown';
+    install?: string;
+}
+/**
+ * What a registration's command line would start: `npx @synergenius/flow-weaver@latest`
+ * means whatever npm serves. A path to a `flow-weaver.mjs` or a checkout
+ * names an install, compared with the one answering here.
+ */
+export declare function installVerdict(command: string, args: string[], here?: string): {
+    runs: McpRegistration['runs'];
+    install?: string;
+};
+/** The editors with a `flow-weaver` MCP server registered, read from the files `fw mcp-setup` writes. */
+export declare function mcpRegistrations(projectDir: string, home?: string, here?: string): McpRegistration[];
+export interface Probe {
+    url: string;
+    ok: boolean;
+    status?: number;
+    ms?: number;
+    error?: string;
+}
+export interface RegistryStatus extends Probe {
+    scopes: string[];
+    authenticated: boolean;
+    user?: string;
+}
+/** Each configured registry, asked who we are -- which says both that it answers and that the token works. */
+export declare function registryStatuses(projectDir: string, registries?: Registry[]): Promise<RegistryStatus[]>;
+export interface StatusReport {
+    console: {
+        version: string;
+        install: string;
+        project: string;
+        url: string;
+        watching: boolean;
+        runsDir: string;
+    };
+    services: Array<ServiceRecord & {
+        alive: true;
+    }>;
+    mcp: {
+        registrations: McpRegistration[];
+        running: ServiceRecord[];
+    };
+    doctor: DoctorReport;
+    http: Array<{
+        service: ServiceRecord;
+        probe: Probe;
+    }>;
+    registries: RegistryStatus[];
+    at: string;
+}
+export declare function describeStatus(projectDir: string, info: {
+    url: string;
+    watching: boolean;
+    runsDir: string;
+}): Promise<StatusReport>;
+//# sourceMappingURL=status.d.ts.map