@go-go-golems/os-scripting 0.1.0

package/hypercard/index.js

@@ -0,0 +1,12 @@
+export * from './artifacts/artifactRuntime';
+export * from './artifacts/artifactsSelectors';
+export * from './artifacts/artifactsSlice';
+export * from './debug/RuntimeSurfaceDebugWindow';
+export * from './debug/runtimeDebugApp';
+export * from './debug/runtimeDebugRegistry';
+export * from './debug/jsSessionDebugRegistry';
+export * from './editor/CodeEditorWindow';
+export * from './editor/editorLaunch';
+export * from './editor/runtimeSurfaceRef';
+export * from './task-manager';
+export * from './timeline/hypercardCard';

package/hypercard/task-manager/TaskManagerWindow.d.ts

@@ -0,0 +1 @@
+export declare function TaskManagerWindow(): import("react/jsx-runtime").JSX.Element;

package/hypercard/task-manager/TaskManagerWindow.js

@@ -0,0 +1,102 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from 'react';
+import { invokeTaskManagerAction, useRegisteredTaskManagerSources, useTaskManagerRows, } from './taskManagerRegistry';
+function normalize(text) {
+    return typeof text === 'string' ? text.trim().toLowerCase() : '';
+}
+function matchesText(value, query) {
+    if (!query) {
+        return true;
+    }
+    return normalize(value).includes(query);
+}
+function detailSummary(details) {
+    if (!details) {
+        return '—';
+    }
+    const entries = Object.entries(details).filter(([, value]) => value && value !== '—');
+    if (entries.length === 0) {
+        return '—';
+    }
+    return entries.map(([key, value]) => `${key}: ${value}`).join(' · ');
+}
+export function TaskManagerWindow() {
+    const sources = useRegisteredTaskManagerSources();
+    const rows = useTaskManagerRows();
+    const [query, setQuery] = useState('');
+    const [kindFilter, setKindFilter] = useState('all');
+    const [statusFilter, setStatusFilter] = useState('all');
+    const [busyAction, setBusyAction] = useState(null);
+    const [error, setError] = useState(null);
+    const normalizedQuery = normalize(query);
+    const availableKinds = useMemo(() => Array.from(new Set(rows.map((row) => row.kind))).sort(), [rows]);
+    const availableStatuses = useMemo(() => Array.from(new Set(rows.map((row) => row.status))).sort(), [rows]);
+    const filteredRows = useMemo(() => rows.filter((row) => {
+        if (kindFilter !== 'all' && row.kind !== kindFilter) {
+            return false;
+        }
+        if (statusFilter !== 'all' && row.status !== statusFilter) {
+            return false;
+        }
+        if (!normalizedQuery) {
+            return true;
+        }
+        return (matchesText(row.title, normalizedQuery) ||
+            matchesText(row.kind, normalizedQuery) ||
+            matchesText(row.status, normalizedQuery) ||
+            matchesText(row.sourceTitle, normalizedQuery) ||
+            Object.values(row.details ?? {}).some((value) => matchesText(value, normalizedQuery)));
+    }), [rows, kindFilter, statusFilter, normalizedQuery]);
+    const summary = useMemo(() => {
+        const byKind = rows.reduce((acc, row) => {
+            acc[row.kind] = (acc[row.kind] ?? 0) + 1;
+            return acc;
+        }, {});
+        return Object.entries(byKind)
+            .sort(([left], [right]) => left.localeCompare(right))
+            .map(([kind, count]) => `${kind}: ${count}`)
+            .join(' · ');
+    }, [rows]);
+    const td = {
+        padding: '4px 8px',
+        fontSize: 11,
+        borderBottom: '1px solid #ccc',
+        verticalAlign: 'top',
+        color: '#111',
+    };
+    const th = {
+        ...td,
+        fontWeight: 700,
+        background: '#e8e8f0',
+        position: 'sticky',
+        top: 0,
+    };
+    async function handleAction(sourceId, rowId, actionId) {
+        const token = `${sourceId}:${rowId}:${actionId}`;
+        setBusyAction(token);
+        setError(null);
+        try {
+            await invokeTaskManagerAction(sourceId, rowId, actionId);
+        }
+        catch (cause) {
+            setError(cause instanceof Error ? cause.message : String(cause));
+        }
+        finally {
+            setBusyAction((current) => (current === token ? null : current));
+        }
+    }
+    return (_jsxs("div", { style: { padding: 12, fontFamily: 'monospace', fontSize: 12, color: '#111', overflow: 'auto', height: '100%' }, children: [_jsxs("div", { style: { display: 'grid', gap: 10, marginBottom: 12 }, children: [_jsxs("div", { style: { display: 'flex', justifyContent: 'space-between', gap: 12, alignItems: 'baseline', flexWrap: 'wrap' }, children: [_jsxs("div", { children: [_jsx("div", { style: { fontWeight: 700, fontSize: 14 }, children: "Task Manager" }), _jsxs("div", { style: { fontSize: 11, color: '#555' }, children: [sources.length, " sources \u00B7 ", rows.length, " rows", summary ? ` · ${summary}` : ''] })] }), _jsx("div", { style: { fontSize: 11, color: '#555' }, children: "Operator view for runtime sessions and broker-owned JS sessions" })] }), _jsxs("div", { style: { display: 'flex', gap: 8, flexWrap: 'wrap', alignItems: 'end' }, children: [_jsxs("label", { style: { display: 'grid', gap: 4 }, children: [_jsx("span", { style: { fontSize: 11, color: '#555' }, children: "Search" }), _jsx("input", { value: query, onChange: (event) => setQuery(event.target.value), placeholder: "Search title, source, details...", style: { width: 260, padding: '4px 6px', fontFamily: 'inherit', fontSize: 12 } })] }), _jsxs("label", { style: { display: 'grid', gap: 4 }, children: [_jsx("span", { style: { fontSize: 11, color: '#555' }, children: "Kind" }), _jsxs("select", { value: kindFilter, onChange: (event) => setKindFilter(event.target.value), style: { minWidth: 150, padding: '4px 6px', fontFamily: 'inherit', fontSize: 12 }, children: [_jsx("option", { value: "all", children: "All kinds" }), availableKinds.map((kind) => (_jsx("option", { value: kind, children: kind }, kind)))] })] }), _jsxs("label", { style: { display: 'grid', gap: 4 }, children: [_jsx("span", { style: { fontSize: 11, color: '#555' }, children: "Status" }), _jsxs("select", { value: statusFilter, onChange: (event) => setStatusFilter(event.target.value), style: { minWidth: 140, padding: '4px 6px', fontFamily: 'inherit', fontSize: 12 }, children: [_jsx("option", { value: "all", children: "All statuses" }), availableStatuses.map((status) => (_jsx("option", { value: status, children: status }, status)))] })] })] }), error ? (_jsx("div", { style: { padding: '6px 8px', border: '1px solid #c88', background: '#fff2f2', color: '#822' }, children: error })) : null] }), _jsxs("table", { style: { width: '100%', borderCollapse: 'collapse' }, children: [_jsx("thead", { children: _jsxs("tr", { children: [_jsx("th", { style: th, children: "Source" }), _jsx("th", { style: th, children: "Kind" }), _jsx("th", { style: th, children: "Title" }), _jsx("th", { style: th, children: "Status" }), _jsx("th", { style: th, children: "Started" }), _jsx("th", { style: th, children: "Details" }), _jsx("th", { style: th, children: "Actions" })] }) }), _jsxs("tbody", { children: [filteredRows.map((row) => (_jsxs("tr", { children: [_jsx("td", { style: td, children: row.sourceTitle }), _jsx("td", { style: td, children: _jsx("code", { children: row.kind }) }), _jsxs("td", { style: td, children: [_jsx("div", { children: row.title }), _jsx("div", { style: { fontSize: 10, color: '#666' }, children: _jsx("code", { children: row.id }) })] }), _jsx("td", { style: td, children: row.status }), _jsx("td", { style: td, children: row.startedAt ?? '—' }), _jsx("td", { style: td, children: detailSummary(row.details) }), _jsx("td", { style: td, children: _jsx("div", { style: { display: 'flex', gap: 6, flexWrap: 'wrap' }, children: row.actions.map((action) => {
+                                                const token = `${row.sourceId}:${row.id}:${action.id}`;
+                                                const busy = busyAction === token;
+                                                return (_jsx("button", { onClick: () => void handleAction(row.sourceId, row.id, action.id), disabled: busy, style: {
+                                                        fontSize: 10,
+                                                        padding: '1px 6px',
+                                                        borderRadius: 3,
+                                                        border: '1px solid #999',
+                                                        background: busy ? '#ddd' : '#f0f0f0',
+                                                        cursor: busy ? 'progress' : 'pointer',
+                                                    }, children: busy ? '…' : action.label }, action.id));
+                                            }) }) })] }, `${row.sourceId}:${row.id}`))), filteredRows.length === 0 ? (_jsx("tr", { children: _jsx("td", { style: td, colSpan: 7, children: rows.length === 0
+                                        ? 'No task-manager sources are registered yet.'
+                                        : 'No rows match the current search and filter settings.' }) })) : null] })] })] }));
+}

package/hypercard/task-manager/index.d.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './taskManagerRegistry';
+export * from './runtimeSessionSource';
+export * from './jsSessionSource';
+export * from './TaskManagerWindow';
+export * from './taskManagerApp';

package/hypercard/task-manager/index.js

@@ -0,0 +1,6 @@
+export * from './types';
+export * from './taskManagerRegistry';
+export * from './runtimeSessionSource';
+export * from './jsSessionSource';
+export * from './TaskManagerWindow';
+export * from './taskManagerApp';

package/hypercard/task-manager/jsSessionSource.d.ts

@@ -0,0 +1,10 @@
+import type { JsSessionBroker } from '../../repl/jsSessionBroker';
+import type { TaskManagerSource } from './types';
+interface JsSessionTaskManagerSourceOptions {
+    sourceId: string;
+    sourceTitle: string;
+    broker: JsSessionBroker;
+    focusSession?: (sessionId: string) => void;
+}
+export declare function createJsSessionTaskManagerSource(options: JsSessionTaskManagerSourceOptions): TaskManagerSource;
+export {};

package/hypercard/task-manager/jsSessionSource.js

@@ -0,0 +1,49 @@
+export function createJsSessionTaskManagerSource(options) {
+    return {
+        sourceId() {
+            return options.sourceId;
+        },
+        title() {
+            return options.sourceTitle;
+        },
+        listRows() {
+            return options.broker.listSessions().map((session) => ({
+                id: session.sessionId,
+                kind: 'js-session',
+                sourceId: options.sourceId,
+                sourceTitle: options.sourceTitle,
+                title: session.title,
+                status: 'ready',
+                startedAt: session.createdAt,
+                details: {
+                    ownership: 'broker-owned',
+                    globals: String(session.globalNames.length),
+                    globalsPreview: session.globalNames.slice(0, 6).join(', ') || '—',
+                },
+                actions: [
+                    { id: 'focus', label: 'Focus', intent: 'focus' },
+                    { id: 'reset', label: 'Reset', intent: 'reset' },
+                    { id: 'dispose', label: 'Dispose', intent: 'dispose' },
+                ],
+            }));
+        },
+        async invoke(actionId, rowId) {
+            if (actionId === 'focus') {
+                options.focusSession?.(rowId);
+                return;
+            }
+            if (actionId === 'reset') {
+                await options.broker.resetSession(rowId);
+                return;
+            }
+            if (actionId === 'dispose') {
+                options.broker.disposeSession(rowId);
+                return;
+            }
+            throw new Error(`Unsupported JS session action: ${actionId}`);
+        },
+        subscribe(listener) {
+            return options.broker.subscribe(listener);
+        },
+    };
+}

package/hypercard/task-manager/runtimeSessionSource.d.ts

@@ -0,0 +1,26 @@
+import type { RuntimeBundleDefinition } from '@go-go-golems/os-core';
+import type { TaskManagerSource } from './types';
+import { type RuntimeSessionManager } from '../../runtime-session-manager';
+interface RuntimeSessionTaskManagerState {
+    windowing?: {
+        sessions: Record<string, {
+            nav?: Array<{
+                surface?: string;
+                param?: string;
+            }>;
+        }>;
+    };
+}
+interface RuntimeSessionTaskManagerSourceOptions {
+    sourceId?: string;
+    sourceTitle?: string;
+    getState: () => RuntimeSessionTaskManagerState;
+    dispatch: (action: unknown) => void;
+    bundles: RuntimeBundleDefinition[];
+    ownerAppId: string;
+    focusJsConsole?: (sessionId: string) => void;
+    subscribe: (listener: () => void) => () => void;
+    manager?: RuntimeSessionManager;
+}
+export declare function createRuntimeSessionTaskManagerSource(options: RuntimeSessionTaskManagerSourceOptions): TaskManagerSource;
+export {};

package/hypercard/task-manager/runtimeSessionSource.js

@@ -0,0 +1,123 @@
+import { openWindow } from '@go-go-golems/os-core/desktop-core';
+import { buildRuntimeDebugWindowPayload } from '../debug/runtimeDebugApp';
+import { DEFAULT_RUNTIME_SESSION_MANAGER, } from '../../runtime-session-manager';
+function buildBundleSurfaceWindowPayload(bundle, surfaceId, param) {
+    const surface = bundle.surfaces[surfaceId];
+    if (!surface) {
+        return null;
+    }
+    const sessionId = typeof globalThis.crypto?.randomUUID === 'function'
+        ? `task-manager:${bundle.id}:${surfaceId}:${globalThis.crypto.randomUUID()}`
+        : `task-manager:${bundle.id}:${surfaceId}:${Date.now()}`;
+    return {
+        id: `window:task-manager:${bundle.id}:${surfaceId}:${sessionId}`,
+        title: surface.title ?? surfaceId,
+        icon: surface.icon ?? '📄',
+        bounds: { x: 180, y: 56, w: 960, h: 700 },
+        content: {
+            kind: 'surface',
+            surface: {
+                bundleId: bundle.id,
+                surfaceId,
+                surfaceSessionId: sessionId,
+                param,
+            },
+        },
+        dedupeKey: `task-surface:${bundle.id}:${surfaceId}:${param ?? ''}`,
+    };
+}
+function currentSurfaceForSession(session, navSessions) {
+    const nav = navSessions?.sessions?.[session.sessionId]?.nav;
+    if (Array.isArray(nav) && nav.length > 0) {
+        const current = nav[nav.length - 1];
+        if (typeof current?.surface === 'string') {
+            return { surfaceId: current.surface, param: current.param };
+        }
+    }
+    return { surfaceId: session.surfaces[0] ?? null };
+}
+export function createRuntimeSessionTaskManagerSource(options) {
+    const bundlesById = new Map(options.bundles.map((bundle) => [bundle.id, bundle]));
+    const sourceId = options.sourceId ?? 'runtime-sessions';
+    const sourceTitle = options.sourceTitle ?? 'Runtime Sessions';
+    const manager = options.manager ?? DEFAULT_RUNTIME_SESSION_MANAGER;
+    return {
+        sourceId() {
+            return sourceId;
+        },
+        title() {
+            return sourceTitle;
+        },
+        listRows() {
+            const state = options.getState();
+            const windowing = state.windowing;
+            return manager.listSessions().map((session) => {
+                const bundle = bundlesById.get(session.bundleId);
+                const currentSurface = currentSurfaceForSession(session, windowing);
+                return {
+                    id: session.sessionId,
+                    kind: 'runtime-session',
+                    sourceId,
+                    sourceTitle,
+                    title: `${bundle?.name ?? session.bundleId}${currentSurface.surfaceId ? ` · ${currentSurface.surfaceId}` : ''}`,
+                    status: session.status,
+                    details: {
+                        bundleId: session.bundleId,
+                        bundleName: bundle?.name ?? session.bundleId,
+                        ownership: session.ownership.kind,
+                        currentSurface: currentSurface.surfaceId ?? '—',
+                        surfaceCount: String(session.surfaces.length),
+                        attachedViews: String(session.attachedViewIds.length),
+                    },
+                    actions: [
+                        { id: 'open', label: 'Open', intent: 'open' },
+                        { id: 'js-console', label: 'JS Console', intent: 'custom' },
+                        { id: 'inspect', label: 'Inspect', intent: 'inspect' },
+                    ],
+                };
+            });
+        },
+        invoke(actionId, rowId) {
+            const state = options.getState();
+            const session = manager.listSessions().find((entry) => entry.sessionId === rowId);
+            if (!session) {
+                throw new Error(`Unknown runtime session: ${rowId}`);
+            }
+            if (actionId === 'inspect') {
+                options.dispatch(openWindow(buildRuntimeDebugWindowPayload({
+                    appId: options.ownerAppId,
+                })));
+                return;
+            }
+            if (actionId === 'js-console') {
+                options.focusJsConsole?.(rowId);
+                return;
+            }
+            if (actionId === 'open') {
+                const bundle = bundlesById.get(session.bundleId);
+                if (!bundle) {
+                    throw new Error(`Unknown runtime bundle: ${session.bundleId}`);
+                }
+                const currentSurface = currentSurfaceForSession(session, state.windowing);
+                if (!currentSurface.surfaceId) {
+                    throw new Error(`Runtime session has no active surface: ${rowId}`);
+                }
+                const payload = buildBundleSurfaceWindowPayload(bundle, currentSurface.surfaceId, currentSurface.param);
+                if (!payload) {
+                    throw new Error(`Unknown runtime surface: ${session.bundleId}:${currentSurface.surfaceId}`);
+                }
+                options.dispatch(openWindow(payload));
+                return;
+            }
+            throw new Error(`Unsupported runtime session action: ${actionId}`);
+        },
+        subscribe(listener) {
+            const unregisterStore = options.subscribe(listener);
+            const unregisterManager = manager.subscribe(listener);
+            return () => {
+                unregisterManager();
+                unregisterStore();
+            };
+        },
+    };
+}

package/hypercard/task-manager/taskManagerApp.d.ts

@@ -0,0 +1,16 @@
+import type { OpenWindowPayload } from '@go-go-golems/os-core/desktop-core';
+export declare const HYPERCARD_TASK_MANAGER_APP_ID = "hypercard-task-manager";
+export declare const HYPERCARD_TASK_MANAGER_INSTANCE_ID = "tasks";
+export interface BuildTaskManagerWindowPayloadOptions {
+    appId?: string;
+    instanceId?: string;
+    title?: string;
+    icon?: string;
+    bounds?: OpenWindowPayload['bounds'];
+    dedupeKey?: string;
+}
+export interface TaskManagerAppWindowProps {
+    instanceId: string;
+}
+export declare function buildTaskManagerWindowPayload(options?: BuildTaskManagerWindowPayloadOptions): OpenWindowPayload;
+export declare function TaskManagerAppWindow({ instanceId }: TaskManagerAppWindowProps): import("react/jsx-runtime").JSX.Element;

package/hypercard/task-manager/taskManagerApp.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { TaskManagerWindow } from './TaskManagerWindow';
+export const HYPERCARD_TASK_MANAGER_APP_ID = 'hypercard-task-manager';
+export const HYPERCARD_TASK_MANAGER_INSTANCE_ID = 'tasks';
+export function buildTaskManagerWindowPayload(options = {}) {
+    const appId = options.appId ?? HYPERCARD_TASK_MANAGER_APP_ID;
+    const instanceId = options.instanceId ?? HYPERCARD_TASK_MANAGER_INSTANCE_ID;
+    return {
+        id: `window:${appId}:${instanceId}`,
+        title: options.title ?? 'Task Manager',
+        icon: options.icon ?? '🗂️',
+        bounds: options.bounds ?? { x: 120, y: 52, w: 860, h: 520 },
+        content: {
+            kind: 'app',
+            appKey: `${appId}:${instanceId}`,
+        },
+        dedupeKey: options.dedupeKey ?? `${appId}:${instanceId}`,
+    };
+}
+export function TaskManagerAppWindow({ instanceId }) {
+    if (instanceId !== HYPERCARD_TASK_MANAGER_INSTANCE_ID) {
+        return (_jsxs("section", { style: { padding: 12, display: 'grid', gap: 8 }, children: [_jsx("strong", { children: "Task Manager" }), _jsxs("span", { children: ["Unknown task manager window instance: ", instanceId] })] }));
+    }
+    return _jsx(TaskManagerWindow, {});
+}

package/hypercard/task-manager/taskManagerRegistry.d.ts

@@ -0,0 +1,10 @@
+import type { TaskManagerRow, TaskManagerSource } from './types';
+export declare function registerTaskManagerSource(source: TaskManagerSource): void;
+export declare function unregisterTaskManagerSource(sourceId: string): void;
+export declare function clearTaskManagerSources(): void;
+export declare function listTaskManagerSources(): TaskManagerSource[];
+export declare function listTaskManagerRows(): TaskManagerRow[];
+export declare function invokeTaskManagerAction(sourceId: string, rowId: string, actionId: string): Promise<void>;
+export declare function subscribeTaskManagerSources(listener: () => void): () => void;
+export declare function useRegisteredTaskManagerSources(): TaskManagerSource[];
+export declare function useTaskManagerRows(): TaskManagerRow[];

package/hypercard/task-manager/taskManagerRegistry.js

@@ -0,0 +1,75 @@
+import { useSyncExternalStore } from 'react';
+const registeredSources = new Map();
+const listeners = new Set();
+let registeredSourcesSnapshot = [];
+let registeredRowsSnapshot = [];
+const sourceUnsubscribes = new Map();
+function refreshSnapshots() {
+    registeredSourcesSnapshot = Array.from(registeredSources.values());
+    registeredRowsSnapshot = registeredSourcesSnapshot.flatMap((source) => source.listRows());
+}
+function emitChange() {
+    for (const listener of listeners) {
+        listener();
+    }
+}
+function refreshAndEmit() {
+    refreshSnapshots();
+    emitChange();
+}
+export function registerTaskManagerSource(source) {
+    const sourceId = source?.sourceId?.();
+    if (!sourceId) {
+        return;
+    }
+    if (registeredSources.get(sourceId) === source) {
+        return;
+    }
+    sourceUnsubscribes.get(sourceId)?.();
+    registeredSources.set(sourceId, source);
+    sourceUnsubscribes.set(sourceId, source.subscribe(refreshAndEmit));
+    refreshAndEmit();
+}
+export function unregisterTaskManagerSource(sourceId) {
+    if (!registeredSources.has(sourceId)) {
+        return;
+    }
+    sourceUnsubscribes.get(sourceId)?.();
+    sourceUnsubscribes.delete(sourceId);
+    registeredSources.delete(sourceId);
+    refreshAndEmit();
+}
+export function clearTaskManagerSources() {
+    if (registeredSources.size === 0) {
+        return;
+    }
+    sourceUnsubscribes.forEach((unsubscribe) => unsubscribe());
+    sourceUnsubscribes.clear();
+    registeredSources.clear();
+    refreshAndEmit();
+}
+export function listTaskManagerSources() {
+    return registeredSourcesSnapshot;
+}
+export function listTaskManagerRows() {
+    return registeredRowsSnapshot;
+}
+export async function invokeTaskManagerAction(sourceId, rowId, actionId) {
+    const source = registeredSources.get(sourceId);
+    if (!source) {
+        throw new Error(`Unknown task manager source: ${sourceId}`);
+    }
+    await source.invoke(actionId, rowId);
+}
+export function subscribeTaskManagerSources(listener) {
+    listeners.add(listener);
+    return () => {
+        listeners.delete(listener);
+    };
+}
+export function useRegisteredTaskManagerSources() {
+    return useSyncExternalStore(subscribeTaskManagerSources, listTaskManagerSources, listTaskManagerSources);
+}
+export function useTaskManagerRows() {
+    return useSyncExternalStore(subscribeTaskManagerSources, listTaskManagerRows, listTaskManagerRows);
+}

package/hypercard/task-manager/types.d.ts

@@ -0,0 +1,25 @@
+export interface TaskManagerAction {
+    id: string;
+    label: string;
+    intent: 'open' | 'focus' | 'inspect' | 'reset' | 'dispose' | 'terminate' | 'custom';
+}
+export interface TaskManagerRow {
+    id: string;
+    kind: string;
+    sourceId: string;
+    sourceTitle: string;
+    title: string;
+    status: string;
+    startedAt?: string;
+    updatedAt?: string;
+    tags?: string[];
+    details?: Record<string, string>;
+    actions: TaskManagerAction[];
+}
+export interface TaskManagerSource {
+    sourceId(): string;
+    title(): string;
+    listRows(): TaskManagerRow[];
+    invoke(actionId: string, rowId: string): Promise<void> | void;
+    subscribe(listener: () => void): () => void;
+}

package/hypercard/task-manager/types.js

@@ -0,0 +1 @@
+export {};

package/hypercard/timeline/hypercardCard.d.ts

@@ -0,0 +1,5 @@
+import type { RenderContext, RenderEntity } from '@go-go-golems/os-chat';
+export declare function HypercardCardRenderer({ e, ctx }: {
+    e: RenderEntity;
+    ctx?: RenderContext;
+}): import("react/jsx-runtime").JSX.Element;

package/hypercard/timeline/hypercardCard.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useDispatch } from 'react-redux';
+import { SyntaxHighlight, recordField, stringField } from '@go-go-golems/os-chat';
+import { openWindow } from '@go-go-golems/os-core/desktop-core';
+import { buildArtifactOpenWindowPayload, normalizeArtifactId } from '../artifacts/artifactRuntime';
+import { openCodeEditor } from '../editor/editorLaunch';
+function artifactPayload(props) {
+    return recordField(props, 'result') ?? props;
+}
+function artifactData(props) {
+    return recordField(artifactPayload(props) ?? {}, 'data');
+}
+function artifactIdFromCardArtifact(props) {
+    const payload = artifactPayload(props);
+    const payloadData = artifactData(props);
+    const artifact = recordField(payload ?? {}, 'artifact') ??
+        recordField(payloadData ?? {}, 'artifact');
+    return stringField(props, 'artifactId') ?? stringField(artifact ?? {}, 'id') ?? '';
+}
+function runtimeSurfaceId(props) {
+    const payload = artifactPayload(props);
+    const payloadData = artifactData(props);
+    const card = recordField(payload ?? {}, 'card') ??
+        recordField(payloadData ?? {}, 'card');
+    return stringField(props, 'runtimeSurfaceId') ?? stringField(card ?? {}, 'id') ?? '';
+}
+function runtimeSurfaceCode(props) {
+    const payload = artifactPayload(props);
+    const payloadData = artifactData(props);
+    const card = recordField(payload ?? {}, 'card') ??
+        recordField(payloadData ?? {}, 'card');
+    return stringField(props, 'runtimeSurfaceCode') ?? stringField(card ?? {}, 'code') ?? '';
+}
+function runtimeSurfacePackId(props) {
+    const payload = artifactPayload(props);
+    const payloadData = artifactData(props);
+    const runtime = recordField(payload ?? {}, 'runtime') ??
+        recordField(payloadData ?? {}, 'runtime');
+    return stringField(props, 'packId') ?? stringField(runtime ?? {}, 'pack') ?? '';
+}
+function titleFromArtifactCard(props) {
+    const payload = artifactPayload(props);
+    return (stringField(props, 'title') ??
+        stringField(props, 'name') ??
+        stringField(payload ?? {}, 'title') ??
+        stringField(payload ?? {}, 'name') ??
+        'Card') ??
+        'Card';
+}
+function detailFromArtifactCard(props) {
+    const payload = artifactPayload(props);
+    const error = stringField(props, 'error') ?? stringField(payload ?? {}, 'error') ?? '';
+    if (error) {
+        return { status: 'error', detail: error };
+    }
+    return {
+        status: stringField(props, 'status') ?? 'success',
+        detail: stringField(props, 'detail') ?? 'ready',
+    };
+}
+export function HypercardCardRenderer({ e, ctx }) {
+    const dispatch = useDispatch();
+    const props = e.props;
+    const title = titleFromArtifactCard(props);
+    const { status, detail } = detailFromArtifactCard(props);
+    const artifactId = artifactIdFromCardArtifact(props);
+    const surfaceId = runtimeSurfaceId(props);
+    const surfaceCode = runtimeSurfaceCode(props);
+    const surfacePackId = runtimeSurfacePackId(props);
+    const bundleId = props.stackId ? String(props.stackId) : undefined;
+    const hasRuntimeSurface = surfaceId.trim().length > 0;
+    const hasSurfaceCode = surfaceCode.trim().length > 0;
+    const hasSurfacePackId = surfacePackId.trim().length > 0;
+    const canOpenArtifact = Boolean(normalizeArtifactId(artifactId) &&
+        hasRuntimeSurface &&
+        hasSurfacePackId &&
+        status !== 'streaming' &&
+        status !== 'pending');
+    const canEditCode = hasRuntimeSurface && hasSurfaceCode && status !== 'streaming' && status !== 'pending';
+    const openArtifact = () => {
+        const payload = buildArtifactOpenWindowPayload({
+            artifactId,
+            title,
+            runtimeSurfaceId: surfaceId,
+            bundleId,
+        });
+        if (!payload) {
+            return;
+        }
+        dispatch(openWindow(payload));
+    };
+    const editArtifact = () => {
+        if (!hasRuntimeSurface || !hasSurfaceCode) {
+            return;
+        }
+        openCodeEditor(dispatch, { ownerAppId: 'inventory', surfaceId }, surfaceCode, surfacePackId);
+    };
+    return (_jsxs("div", { "data-part": "chat-message", "data-role": "system", children: [_jsx("div", { "data-part": "chat-role", children: "Card:" }), _jsxs("div", { style: { fontSize: 11, whiteSpace: 'pre-wrap' }, children: [_jsx("strong", { children: title }), surfaceId ? ` · runtime=${surfaceId}` : '', detail ? ` — ${detail}` : ''] }), _jsxs("div", { style: { fontSize: 11, whiteSpace: 'pre-wrap', opacity: 0.8 }, children: ["status: ", status] }), hasSurfaceCode && (_jsx(SyntaxHighlight, { code: surfaceCode, language: "javascript", maxLines: 18, style: { marginTop: 6 } })), ctx?.mode === 'debug' && (_jsx("pre", { style: {
+                    margin: '6px 0 0',
+                    fontSize: 10,
+                    whiteSpace: 'pre-wrap',
+                    opacity: 0.9,
+                }, children: JSON.stringify(e.props, null, 2) })), (canOpenArtifact || canEditCode) && (_jsxs("div", { style: { marginTop: 4, display: 'flex', gap: 6 }, children: [canOpenArtifact && (_jsx("button", { type: "button", "data-part": "btn", onClick: openArtifact, children: "Open" })), canEditCode && (_jsx("button", { type: "button", "data-part": "btn", onClick: editArtifact, children: "Edit" }))] }))] }));
+}

package/index.d.ts

@@ -0,0 +1,18 @@
+export * from './app';
+export * from './plugin-runtime';
+export * from './repl/hypercardReplDriver';
+export * from './repl/attachedJsSessionRegistry';
+export * from './repl/attachedRuntimeSessionRegistry';
+export * from './repl/jsReplDriver';
+export * from './repl/jsSessionBroker';
+export * from './repl/runtimeBroker';
+export * from './runtime-session-manager';
+export * from './features/runtimeSessions';
+export * from './hypercard';
+export * from './hypercard/debug/runtimeDebugApp';
+export * from './hypercard/debug/runtimeDebugRegistry';
+export * from './hypercard/task-manager';
+export * from './runtime-packs';
+export * from './runtime-packages';
+export { RuntimeSurfaceSessionHost, type RuntimeSurfaceSessionHostProps } from './runtime-host/RuntimeSurfaceSessionHost';
+export { dispatchRuntimeAction } from './runtime-host/pluginIntentRouting';