@tutti-os/workspace-terminal 0.0.1

package/dist/styles/terminal.css

@@ -0,0 +1,303 @@
+@import "@xterm/xterm/css/xterm.css";
+
+.workbench-window-shell[data-workbench-node-type-id="workspace-terminal"]
+  .workbench-window {
+  box-shadow:
+    var(--workbench-window-shadow),
+    0 8px 24px var(--shadow-elevated);
+}
+
+.workspace-terminal {
+  position: relative;
+  display: flex;
+  min-height: 0;
+  height: 100%;
+  flex-direction: column;
+  background: var(--nextop-surface, #111);
+  color: var(--nextop-text, #f4f4f5);
+}
+
+.workspace-terminal__header {
+  display: flex;
+  flex: none;
+  height: var(--workbench-header-height);
+  align-items: center;
+  justify-content: space-between;
+  gap: 12px;
+  border-bottom: 1px solid var(--border-1);
+  background: var(--background-panel);
+  color: var(--text-primary);
+  padding: 0 8px 0 12px;
+  font-size: 13px;
+  user-select: none;
+}
+
+.workspace-terminal__header-main {
+  display: flex;
+  min-width: 0;
+  align-items: center;
+  gap: 8px;
+}
+
+.workspace-terminal__title {
+  min-width: 0;
+  overflow: hidden;
+  font-weight: 600;
+  line-height: 1.35;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.workspace-terminal__status-tag {
+  flex: none;
+}
+
+.workspace-terminal__actions {
+  display: flex;
+  flex: none;
+  align-items: center;
+  gap: 4px;
+}
+
+.workspace-terminal__icon-button {
+  display: grid;
+  width: 28px;
+  height: 28px;
+  place-items: center;
+  border: 0;
+  border-radius: 6px;
+  background: transparent;
+  color: inherit;
+}
+
+.workspace-terminal__body {
+  min-height: 0;
+  flex: 1;
+}
+
+.workspace-terminal__surface-shell {
+  position: relative;
+  min-height: 0;
+  height: 100%;
+}
+
+.workspace-terminal__find {
+  position: absolute;
+  top: 10px;
+  right: 10px;
+  z-index: 2;
+  display: grid;
+  grid-template-columns: minmax(150px, 210px) 30px 30px 34px 34px;
+  align-items: center;
+  gap: 5px;
+  max-width: min(352px, calc(100% - 20px));
+  border: 1px solid rgb(255 255 255 / 10%);
+  border-radius: 999px;
+  background: linear-gradient(180deg, rgb(39 39 42 / 94%), rgb(15 23 42 / 92%));
+  box-shadow:
+    0 12px 28px rgb(0 0 0 / 30%),
+    inset 0 1px 0 rgb(255 255 255 / 7%);
+  padding: 5px;
+  backdrop-filter: blur(10px);
+  animation: workspace-terminal__find-enter 140ms ease-out;
+}
+
+.workspace-terminal__find input {
+  min-width: 0;
+  height: 28px;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  background: rgb(5 8 18 / 78%);
+  color: rgb(244 244 245);
+  font-size: 12px;
+  line-height: 1;
+  outline: none;
+  padding: 0 11px;
+  box-shadow: inset 0 1px 2px rgb(0 0 0 / 24%);
+}
+
+.workspace-terminal__find input:focus {
+  border-color: rgb(125 211 252 / 44%);
+  box-shadow:
+    inset 0 1px 2px rgb(0 0 0 / 24%),
+    0 0 0 1px rgb(125 211 252 / 22%);
+}
+
+.workspace-terminal__find button {
+  display: grid;
+  min-width: 30px;
+  height: 28px;
+  place-items: center;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  background: rgb(255 255 255 / 2%);
+  color: rgb(244 244 245 / 82%);
+  font-size: 11px;
+  line-height: 1;
+  padding: 0 8px;
+  transition:
+    background-color 120ms ease,
+    border-color 120ms ease,
+    color 120ms ease,
+    transform 120ms ease;
+}
+
+.workspace-terminal__find button:hover {
+  background: rgb(255 255 255 / 7%);
+  color: rgb(244 244 245);
+}
+
+.workspace-terminal__find button:active {
+  transform: translateY(1px);
+}
+
+.workspace-terminal__find button[aria-pressed="true"] {
+  border-color: rgb(125 211 252 / 18%);
+  background: rgb(14 116 144 / 24%);
+  color: rgb(224 242 254);
+}
+
+.workspace-terminal__find button:focus-visible {
+  border-color: rgb(125 211 252 / 42%);
+  outline: none;
+}
+
+.workspace-terminal__find-toggle {
+  font-weight: 600;
+  letter-spacing: 0.02em;
+}
+
+.workspace-terminal__find-nav {
+  position: relative;
+  min-width: 30px;
+  padding: 0;
+}
+
+.workspace-terminal__find-nav::before {
+  content: "";
+  width: 7px;
+  height: 7px;
+  border-top: 1.5px solid currentColor;
+  border-right: 1.5px solid currentColor;
+}
+
+.workspace-terminal__find-nav--previous::before {
+  transform: rotate(-135deg);
+}
+
+.workspace-terminal__find-nav--next::before {
+  transform: rotate(45deg);
+}
+
+@keyframes workspace-terminal__find-enter {
+  from {
+    opacity: 0;
+    transform: translateY(-4px) scale(0.985);
+  }
+
+  to {
+    opacity: 1;
+    transform: translateY(0) scale(1);
+  }
+}
+
+.workspace-terminal__xterm {
+  height: 100%;
+  min-height: 0;
+  overflow: hidden;
+}
+
+.workspace-terminal__xterm .xterm {
+  height: 100%;
+  padding: 8px;
+}
+
+.workspace-terminal__surface-error {
+  position: absolute;
+  right: 8px;
+  bottom: 8px;
+  max-width: min(420px, calc(100% - 16px));
+  border: 1px solid rgb(248 113 113 / 50%);
+  border-radius: 6px;
+  background: rgb(69 10 10 / 92%);
+  color: rgb(254 226 226);
+  font-size: 12px;
+  line-height: 1.4;
+  padding: 6px 8px;
+}
+
+.workspace-terminal__placeholder {
+  display: grid;
+  height: 100%;
+  min-height: 160px;
+  place-items: center;
+  color: var(--nextop-text-muted, rgb(244 244 245 / 68%));
+}
+
+.workspace-terminal__close-guard {
+  position: absolute;
+  inset: 0;
+  z-index: 4;
+  display: grid;
+  place-content: center;
+  gap: 12px;
+  background: rgb(0 0 0 / 42%);
+}
+
+.workspace-terminal__close-guard > h2,
+.workspace-terminal__close-guard > p,
+.workspace-terminal__close-guard > code,
+.workspace-terminal__close-guard-actions {
+  width: min(360px, calc(100vw - 48px));
+}
+
+.workspace-terminal__close-guard > h2 {
+  margin: 0;
+  font-size: 16px;
+}
+
+.workspace-terminal__close-guard > p {
+  margin: 0;
+  color: var(--nextop-text-muted, rgb(244 244 245 / 68%));
+  font-size: 13px;
+  line-height: 1.5;
+}
+
+.workspace-terminal__close-guard > code {
+  overflow: hidden;
+  border-radius: 4px;
+  background: rgb(0 0 0 / 32%);
+  color: inherit;
+  font-size: 12px;
+  padding: 6px 8px;
+  text-overflow: ellipsis;
+  white-space: nowrap;
+}
+
+.workspace-terminal__close-guard-actions {
+  display: flex;
+  justify-content: flex-end;
+  gap: 8px;
+}
+
+.workspace-terminal__close-error {
+  position: absolute;
+  right: 8px;
+  bottom: 8px;
+  z-index: 5;
+  max-width: min(420px, calc(100% - 16px));
+  border: 1px solid rgb(248 113 113 / 50%);
+  border-radius: 6px;
+  background: rgb(69 10 10 / 92%);
+  color: rgb(254 226 226);
+  font-size: 12px;
+  line-height: 1.4;
+  padding: 6px 8px;
+}
+
+.workspace-terminal__dock-icon {
+  font-family:
+    ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono",
+    "Courier New", monospace;
+  font-weight: 700;
+}

package/dist/workbench/index.d.ts

@@ -0,0 +1,59 @@
+import { ReactNode } from 'react';
+import { WorkbenchHostExternalStateSource, WorkbenchFrame, WorkbenchHostLaunchRequest, WorkbenchHostDockEntry, WorkbenchContribution, WorkbenchHostLaunchResult, WorkbenchHostNodeDefinition } from '@tutti-os/workbench-surface';
+import { TerminalNodeExternalState, TerminalHeaderAccessoryRenderer, TerminalCloseGuardResult, TerminalLaunchInput } from '../contracts/index.js';
+import { T as TerminalNodeFeature } from '../feature-sh6KDO7B.js';
+import '@tutti-os/ui-i18n-runtime';
+import '../i18n/index.js';
+
+interface TerminalWorkbenchIntent {
+    cwd?: string | null;
+    initialInput?: string | null;
+    profileId?: string | null;
+}
+interface CreateTerminalWorkbenchNodeDefinitionInput {
+    feature: TerminalNodeFeature;
+    frame?: WorkbenchFrame;
+    headerAccessory?: TerminalHeaderAccessoryRenderer;
+    title?: string;
+    typeId?: string;
+}
+type TerminalWorkbenchLaunchInputResolver = (request: WorkbenchHostLaunchRequest) => Promise<Partial<Omit<TerminalLaunchInput, "reason" | "workspaceId">>> | Partial<Omit<TerminalLaunchInput, "reason" | "workspaceId">>;
+interface CreateTerminalWorkbenchLaunchHandlerInput {
+    feature: TerminalNodeFeature;
+    frame?: WorkbenchFrame;
+    resolveLaunchInput?: TerminalWorkbenchLaunchInputResolver;
+    typeId?: string;
+}
+interface CreateTerminalDockEntryInput {
+    dockIcon?: ReactNode;
+    feature: TerminalNodeFeature;
+    id?: string;
+    order?: number;
+    sectionId?: string;
+    typeId?: string;
+}
+interface TerminalWorkbenchContributionCloseFailure {
+    error: unknown;
+    sessionId: string;
+    status?: TerminalNodeExternalState["status"];
+}
+interface CreateTerminalWorkbenchContributionInput {
+    contributionId?: string;
+    dockEntry?: Omit<CreateTerminalDockEntryInput, "feature">;
+    externalStateSource?: WorkbenchHostExternalStateSource<TerminalNodeExternalState | null, unknown>;
+    feature: TerminalNodeFeature;
+    getTerminalState?: (sessionId: string) => TerminalNodeExternalState | null;
+    node?: Omit<CreateTerminalWorkbenchNodeDefinitionInput, "feature">;
+    onCloseFailure?: (failure: TerminalWorkbenchContributionCloseFailure) => void;
+    onConfirmClose?: (guard: TerminalCloseGuardResult) => Promise<boolean> | boolean;
+    resolveLaunchInput?: TerminalWorkbenchLaunchInputResolver;
+    shouldCloseAfterCloseFailure?: (failure: TerminalWorkbenchContributionCloseFailure) => boolean;
+    typeId?: string;
+}
+declare const defaultTerminalWorkbenchTypeId = "workspace-terminal";
+declare function createTerminalWorkbenchNodeDefinition({ feature, frame, headerAccessory, title, typeId }: CreateTerminalWorkbenchNodeDefinitionInput): WorkbenchHostNodeDefinition<TerminalNodeExternalState>;
+declare function createTerminalDockEntry({ dockIcon, feature, id, order, sectionId, typeId }: CreateTerminalDockEntryInput): WorkbenchHostDockEntry;
+declare function createTerminalWorkbenchLaunchHandler({ feature, frame, resolveLaunchInput, typeId }: CreateTerminalWorkbenchLaunchHandlerInput): (request: WorkbenchHostLaunchRequest) => Promise<WorkbenchHostLaunchResult | null>;
+declare function createTerminalWorkbenchContribution({ contributionId, dockEntry, externalStateSource, feature, getTerminalState, node, onCloseFailure, onConfirmClose, resolveLaunchInput, shouldCloseAfterCloseFailure, typeId }: CreateTerminalWorkbenchContributionInput): WorkbenchContribution;
+
+export { type CreateTerminalDockEntryInput, type CreateTerminalWorkbenchContributionInput, type CreateTerminalWorkbenchLaunchHandlerInput, type CreateTerminalWorkbenchNodeDefinitionInput, type TerminalWorkbenchContributionCloseFailure, type TerminalWorkbenchIntent, type TerminalWorkbenchLaunchInputResolver, createTerminalDockEntry, createTerminalWorkbenchContribution, createTerminalWorkbenchLaunchHandler, createTerminalWorkbenchNodeDefinition, defaultTerminalWorkbenchTypeId };

package/dist/workbench/index.js

@@ -0,0 +1,317 @@
+import {
+  TerminalNode,
+  TerminalNodeHeader,
+  acquireTerminalSessionController
+} from "../chunk-FEJT6FJ4.js";
+import {
+  closeTerminalSession,
+  isTerminalSessionEndedStatus
+} from "../chunk-56B5GYMU.js";
+import "../chunk-65BWWZQV.js";
+
+// src/workbench/index.ts
+import { createElement } from "react";
+
+// src/workbench/bodyProps.ts
+function resolveTerminalWorkbenchBodyProps({
+  context,
+  feature
+}) {
+  return {
+    externalState: context.externalNodeState,
+    feature,
+    nodeId: context.node.id,
+    onFocusRequest: context.isFocused ? void 0 : () => context.focus(),
+    sessionId: context.node.data.instanceKey ?? null,
+    showHeader: false
+  };
+}
+
+// src/workbench/launchAnalytics.ts
+function resolveTerminalLaunchAnalyticsTrigger(request) {
+  switch (request.reason) {
+    case "dock":
+      return "dock";
+    case "launchpad":
+      return "launchpad";
+    case "shortcut":
+      return "keyboard";
+    case "host":
+      return hasInitialInput(request.payload) ? "agent_command" : "launchpad";
+    default:
+      return "launchpad";
+  }
+}
+function hasInitialInput(payload) {
+  if (!payload || typeof payload !== "object") {
+    return false;
+  }
+  const typed = payload;
+  return typeof typed.initialInput === "string" && typed.initialInput.trim().length > 0;
+}
+
+// src/workbench/windowCloseEffect.ts
+async function resolveTerminalWindowCloseEffect({
+  closeGuard,
+  description,
+  externalNodeState,
+  nodeId,
+  sessionId,
+  title,
+  typeId
+}) {
+  const status = externalNodeState?.status ?? "created";
+  if (status === "created" || isTerminalSessionEndedStatus(status)) {
+    return null;
+  }
+  const resolvedSessionId = sessionId ?? externalNodeState?.sessionId ?? null;
+  if (resolvedSessionId) {
+    try {
+      const guard = await closeGuard.check({ sessionId: resolvedSessionId });
+      if (!guard.requiresConfirmation || guard.reason === "not-running" || isTerminalSessionEndedStatus(guard.status)) {
+        return null;
+      }
+    } catch {
+    }
+  }
+  return {
+    description,
+    nodeId,
+    title: externalNodeState?.title?.trim() || title,
+    typeId
+  };
+}
+
+// src/workbench/index.ts
+var defaultTerminalWorkbenchTypeId = "workspace-terminal";
+var defaultTerminalNodeFrame = {
+  height: 520,
+  width: 860,
+  x: 260,
+  y: 140
+};
+function createTerminalWorkbenchNodeDefinition({
+  feature,
+  frame = defaultTerminalNodeFrame,
+  headerAccessory,
+  title,
+  typeId = defaultTerminalWorkbenchTypeId
+}) {
+  return {
+    frame,
+    instance: {
+      mode: "multi"
+    },
+    renderBody: (context) => createElement(
+      TerminalNode,
+      resolveTerminalWorkbenchBodyProps({ context, feature })
+    ),
+    createLease: ({ node }) => {
+      const sessionId = node.data.instanceKey ?? null;
+      if (!sessionId) {
+        return null;
+      }
+      const controller = acquireTerminalSessionController({
+        feature,
+        nodeId: node.id,
+        sessionId
+      });
+      controller.retain();
+      return {
+        release() {
+          controller.release();
+        }
+      };
+    },
+    getWindowCloseEffect: ({ externalNodeState, node }) => resolveTerminalWindowCloseEffect({
+      closeGuard: feature.closeGuard,
+      description: feature.i18n.t("closeGuard.description"),
+      externalNodeState,
+      nodeId: node.id,
+      sessionId: node.data.instanceKey ?? null,
+      title: node.title,
+      typeId
+    }),
+    renderHeader: ({
+      defaultActions,
+      dragHandleProps,
+      externalNodeState,
+      isFocused,
+      node,
+      windowActions
+    }) => createElement(TerminalNodeHeader, {
+      defaultActions,
+      externalState: externalNodeState,
+      feature,
+      headerAccessory,
+      onCloseRequest: () => windowActions.close(),
+      sessionId: node.data.instanceKey ?? null,
+      ...dragHandleProps,
+      onPointerDown: (event) => {
+        dragHandleProps.onPointerDown?.(event);
+        if (!isFocused) {
+          windowActions.focus();
+        }
+      }
+    }),
+    title: title ?? feature.i18n.t("title"),
+    typeId,
+    window: {
+      closable: true,
+      defaultOpen: false,
+      minimizedDock: {
+        kind: "snapshot"
+      },
+      minimizable: true,
+      restoreOnLoad: true
+    }
+  };
+}
+function createTerminalDockEntry({
+  dockIcon,
+  feature,
+  id,
+  order,
+  sectionId,
+  typeId = defaultTerminalWorkbenchTypeId
+}) {
+  return {
+    icon: dockIcon ?? createElement(DefaultTerminalDockIcon),
+    id: id ?? typeId,
+    label: feature.i18n.t("dockLabel"),
+    launchBehavior: "enabled",
+    matchNode: (node) => node.data.typeId === typeId,
+    order,
+    resolvePopupItem: ({ node }) => ({
+      subtitle: node.data.instanceKey ?? node.data.instanceId,
+      title: node.title
+    }),
+    sectionId,
+    typeId,
+    visibility: "always"
+  };
+}
+function createTerminalWorkbenchLaunchHandler({
+  feature,
+  frame = defaultTerminalNodeFrame,
+  resolveLaunchInput,
+  typeId = defaultTerminalWorkbenchTypeId
+}) {
+  return async (request) => {
+    if (request.typeId !== typeId) {
+      return null;
+    }
+    const resolved = await resolveLaunchInput?.(request) ?? {};
+    const descriptor = await feature.launchService.create({
+      cwd: resolved.cwd,
+      initialInput: resolved.initialInput,
+      profileId: resolved.profileId,
+      reason: request.reason === "dock" ? "dock" : "intent",
+      workspaceId: request.workspaceId
+    });
+    return {
+      activation: {
+        payload: {
+          trigger: resolveTerminalLaunchAnalyticsTrigger(request)
+        },
+        type: "terminal-launch"
+      },
+      defaultFrame: frame,
+      dockEntryId: request.dockEntryId ?? typeId,
+      framePolicy: "cascade",
+      instanceId: descriptor.sessionId,
+      instanceKey: descriptor.sessionId,
+      title: descriptor.title,
+      typeId
+    };
+  };
+}
+function createTerminalWorkbenchContribution({
+  contributionId,
+  dockEntry,
+  externalStateSource,
+  feature,
+  getTerminalState,
+  node,
+  onCloseFailure,
+  onConfirmClose,
+  resolveLaunchInput,
+  shouldCloseAfterCloseFailure,
+  typeId = defaultTerminalWorkbenchTypeId
+}) {
+  return {
+    dockEntries: [
+      createTerminalDockEntry({
+        ...dockEntry,
+        feature,
+        typeId
+      })
+    ],
+    externalStateSource,
+    id: contributionId ?? typeId,
+    nodes: [
+      createTerminalWorkbenchNodeDefinition({
+        ...node,
+        feature,
+        typeId
+      })
+    ],
+    onLaunchRequest: createTerminalWorkbenchLaunchHandler({
+      feature,
+      frame: node?.frame,
+      resolveLaunchInput,
+      typeId
+    }),
+    onNodeCloseRequest: onConfirmClose ? (request) => handleTerminalContributionNodeCloseRequest({
+      feature,
+      getTerminalState,
+      onCloseFailure,
+      onConfirmClose,
+      request,
+      shouldCloseAfterCloseFailure,
+      typeId
+    }) : void 0
+  };
+}
+async function handleTerminalContributionNodeCloseRequest(input) {
+  if (input.request.typeId !== input.typeId) {
+    return void 0;
+  }
+  const sessionId = input.request.instanceKey ?? input.request.instanceId;
+  const terminalState = input.getTerminalState?.(sessionId) ?? null;
+  try {
+    const result = await closeTerminalSession({
+      confirm: input.onConfirmClose,
+      feature: input.feature,
+      sessionId,
+      status: terminalState?.status
+    });
+    return result === "closed" ? "close" : "keep-open";
+  } catch (error) {
+    const failure = {
+      error,
+      sessionId,
+      status: terminalState?.status
+    };
+    input.onCloseFailure?.(failure);
+    return input.shouldCloseAfterCloseFailure?.(failure) ? "close" : "keep-open";
+  }
+}
+function DefaultTerminalDockIcon() {
+  return createElement(
+    "span",
+    {
+      "aria-hidden": "true",
+      className: "workspace-terminal__dock-icon"
+    },
+    ">"
+  );
+}
+export {
+  createTerminalDockEntry,
+  createTerminalWorkbenchContribution,
+  createTerminalWorkbenchLaunchHandler,
+  createTerminalWorkbenchNodeDefinition,
+  defaultTerminalWorkbenchTypeId
+};
+//# sourceMappingURL=index.js.map