dsh-git-ui 0.0.1 → 0.0.2

package/src/client/styles.ts

@@ -215,6 +215,9 @@ const globalCss = [
   '.dsh-git-ui__row:hover { background: var(--dsw-alias-interactive-bg-hover); }',
   '.dsh-git-ui__refresh:hover { color: var(--dsw-alias-state-business-primary); }',
   '.dsh-git-ui__refresh:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary); outline-offset: 2px; }',
+  // Git center dialog: widen the platform Modal card (headless mode).
+  '.dsh-git-ui__center { width: min(880px, 100vw); max-height: min(720px, calc(100vh - 48px)); }',
+  '.dsh-git-ui__commit-input:focus-visible { outline: 2px solid var(--dsw-alias-state-business-primary); outline-offset: -2px; }',
 ].join('\n')
 
 /** Ensure the global interaction styles exist (idempotent; browser only). */
@@ -227,3 +230,153 @@ export function ensureGlobalCss(): void {
   tag.textContent = globalCss
   document.head.appendChild(tag)
 }
+
+// ── Git center (management panel) styles ──────────────────────────────────
+
+export const centerShell: CSSProperties = {
+  display: 'flex',
+  flexDirection: 'column',
+  height: '100%',
+  maxHeight: 'min(720px, calc(100vh - 48px))',
+  minHeight: 420,
+  fontSize: 13,
+  lineHeight: '20px',
+  color: 'var(--dsw-alias-label-primary)',
+}
+
+export const centerHeader: CSSProperties = {
+  display: 'flex',
+  alignItems: 'center',
+  gap: 10,
+  padding: '18px 20px 12px',
+  borderBottom: '1px solid var(--dsw-alias-border-l1)',
+  flex: 'none',
+}
+
+export const centerTitle: CSSProperties = {
+  margin: 0,
+  fontSize: 16,
+  lineHeight: '24px',
+  fontWeight: 500,
+  flex: 1,
+  overflow: 'hidden',
+  textOverflow: 'ellipsis',
+  whiteSpace: 'nowrap',
+  color: 'var(--dsw-alias-label-primary)',
+}
+
+export const centerBody: CSSProperties = {
+  flex: 1,
+  overflowY: 'auto',
+  padding: '10px 20px',
+  display: 'flex',
+  flexDirection: 'column',
+  gap: 10,
+}
+
+export const groupTitle: CSSProperties = {
+  margin: '8px 0 4px',
+  fontSize: 11,
+  fontWeight: 600,
+  color: 'var(--dsw-alias-label-secondary)',
+  textTransform: 'uppercase',
+  letterSpacing: 0.4,
+}
+
+export const centerRow: CSSProperties = {
+  display: 'flex',
+  alignItems: 'center',
+  gap: 8,
+  padding: '2px 8px',
+  borderRadius: 8,
+}
+
+export const changeCheckbox: CSSProperties = {
+  flex: 'none',
+  accentColor: 'var(--dsw-alias-state-business-primary)',
+}
+
+export const changePathText: CSSProperties = {
+  overflow: 'hidden',
+  textOverflow: 'ellipsis',
+  whiteSpace: 'nowrap',
+  flex: 1,
+  color: 'var(--dsw-alias-label-primary)',
+  fontSize: 13,
+  lineHeight: '20px',
+}
+
+export const toolRow: CSSProperties = {
+  display: 'flex',
+  alignItems: 'center',
+  gap: 8,
+  flexWrap: 'wrap',
+  padding: '6px 0 2px',
+}
+
+export const commitBox: CSSProperties = {
+  borderTop: '1px solid var(--dsw-alias-border-l1)',
+  padding: '12px 20px 16px',
+  display: 'flex',
+  flexDirection: 'column',
+  gap: 8,
+  flex: 'none',
+  background: 'var(--dsw-alias-bg-layer-1)',
+}
+
+export const commitInput: CSSProperties = {
+  width: '100%',
+  boxSizing: 'border-box',
+  minHeight: 64,
+  resize: 'vertical',
+  border: '1px solid var(--dsw-alias-border-l1)',
+  borderRadius: 8,
+  padding: '6px 10px',
+  fontSize: 14,
+  lineHeight: '22px',
+  fontFamily: 'inherit',
+  background: 'var(--dsw-alias-bg-layer-2)',
+  color: 'var(--dsw-alias-label-primary)',
+}
+
+export const commitFooter: CSSProperties = {
+  display: 'flex',
+  alignItems: 'center',
+  justifyContent: 'space-between',
+  gap: 8,
+}
+
+export const commitHint: CSSProperties = {
+  fontSize: 12,
+  lineHeight: '18px',
+  color: 'var(--dsw-alias-label-tertiary)',
+}
+
+/** Inline error banner (panel-level; stays until dismissed or next action). */
+export const feedbackError: CSSProperties = {
+  display: 'flex',
+  alignItems: 'flex-start',
+  gap: 8,
+  padding: '8px 10px',
+  borderRadius: 8,
+  fontSize: 12,
+  lineHeight: '18px',
+  background: 'var(--dsw-alias-state-error-secondary)',
+  color: 'var(--dsw-alias-state-error-primary)',
+  whiteSpace: 'pre-wrap',
+  wordBreak: 'break-word',
+  maxHeight: 120,
+  overflowY: 'auto',
+}
+
+export const feedbackClose: CSSProperties = {
+  flex: 'none',
+  border: 0,
+  background: 'transparent',
+  padding: '0 2px',
+  cursor: 'pointer',
+  color: 'inherit',
+  fontSize: 13,
+  lineHeight: '18px',
+  opacity: 0.7,
+}

package/src/host/actions.ts

@@ -0,0 +1,127 @@
+/**
+ * Framework-free git management operation runner.
+ *
+ * Same layering as `core.ts`: every dependency is injected structurally, the
+ * whole flow is testable against real temporary git repositories without a
+ * cordis runtime, and `GitStatusService` only adapts host services into the
+ * `SnapshotDeps` face.
+ *
+ * Security model: the browser only ever sends a `sessionId` plus
+ * repository-relative paths (as listed in a snapshot's `changes`). Paths are
+ * validated against the work-tree root (absolute paths and `..` escapes are
+ * rejected) and every git invocation uses `--` so a path can never be
+ * interpreted as an option. Commands run through the same subprocess adapter
+ * as the read-only snapshot flow — no shell is involved.
+ */
+import { resolve, sep } from 'node:path'
+import { resolveWorkspace, runCommand, snapshotForSession, type GitStatusConfig, type SnapshotDeps } from './core.ts'
+import type { GitAction, GitActionResult, GitActionRequest } from './types.ts'
+
+/** Build the command sequence for one action, validating every path against the root. */
+function buildArgv(action: GitAction, root: string): { readonly argv: readonly (readonly string[])[] } | { readonly error: string } {
+  switch (action.kind) {
+    case 'stage':
+      return withPaths(['git', 'add', '--'], action.paths, root)
+    case 'stage-all':
+      return { argv: [['git', 'add', '-A']] }
+    case 'unstage':
+      return withPaths(['git', 'restore', '--staged', '--'], action.paths, root)
+    case 'unstage-all':
+      return { argv: [['git', 'restore', '--staged', '--', '.']] }
+    case 'discard':
+      return withPaths(['git', 'restore', '--'], action.paths, root)
+    case 'discard-all':
+      // Reset the index to HEAD first, then the work tree to the index — the
+      // IDE-style "roll back everything tracked" semantics.
+      return { argv: [['git', 'restore', '--staged', '--', '.'], ['git', 'restore', '--', '.']] }
+    case 'commit': {
+      // Message emptiness is validated by runAction (git-error), not here.
+      const message = action.message.trim()
+      if (action.paths === undefined || action.paths.length === 0) {
+        return { argv: [['git', 'commit', '-m', message]] }
+      }
+      // git commit -- <paths> stages those paths from the work tree and
+      // commits only them (index state of other paths is ignored) — the
+      // IDE-style "commit selected files" semantics.
+      return withPaths(['git', 'commit', '-m', message, '--'], action.paths, root)
+    }
+  }
+}
+
+/** Append validated repo-relative paths behind `--`. */
+function withPaths(prefix: readonly string[], paths: readonly string[], root: string): { readonly argv: readonly (readonly string[])[] } | { readonly error: string } {
+  if (paths.length === 0) return { error: 'no paths given' }
+  for (const path of paths) {
+    if (!isSafePath(path, root)) return { error: `unsafe path: ${path}` }
+  }
+  return { argv: [[...prefix, ...paths]] }
+}
+
+/**
+ * A path is safe when it is repo-relative and stays inside the work tree:
+ * reject absolute paths, drive letters / backslashes, and `..` escapes
+ * (checked via path resolution against the realpath'd root).
+ */
+export function isSafePath(path: string, root: string): boolean {
+  if (path === '') return false
+  if (path.startsWith('/') || path.startsWith('\\') || /^[A-Za-z]:/.test(path)) return false
+  const resolved = resolve(root, path)
+  const prefix = root.endsWith(sep) ? root : `${root}${sep}`
+  return resolved === root || resolved.startsWith(prefix)
+}
+
+/** Map a snapshot-flow failure (which may carry git-unavailable) onto the operation error shape. */
+function operationError(failure: Extract<Awaited<ReturnType<typeof resolveWorkspace>>, { ok: false }>['error']): GitActionResult & { ok: false } {
+  if (failure.code === 'git-unavailable') {
+    return { ok: false, error: { code: 'git-error', message: failure.detail } }
+  }
+  return { ok: false, error: failure }
+}
+
+/**
+ * Execute one management action against the session's repository and return
+ * the refreshed snapshot on success (the caller re-renders from it, so the
+ * UI never waits for the next poll).
+ */
+export async function runAction(
+  deps: SnapshotDeps,
+  config: GitStatusConfig,
+  request: GitActionRequest,
+): Promise<GitActionResult> {
+  const workspace = await resolveWorkspace(deps, request.sessionId)
+  if (!workspace.ok) return operationError(workspace.error)
+  const root = workspace.root
+
+  if (request.action.kind === 'commit' && request.action.message.trim() === '') {
+    return { ok: false, error: { code: 'git-error', message: 'commit message is empty' } }
+  }
+
+  const built = buildArgv(request.action, root)
+  if ('error' in built) return { ok: false, error: { code: 'invalid-path', message: built.error } }
+
+  // Run the command sequence; a failure stops the rest (the first commands
+  // may already have taken effect — they are all idempotent restores).
+  let lastStdout = ''
+  for (const argv of built.argv) {
+    const outcome = await runCommand(deps.run, argv, root, `action ${request.action.kind}`, deps.signal)
+    if ('failure' in outcome) return operationError(outcome.failure)
+    if (outcome.run.timedOut) return { ok: false, error: { code: 'timeout' } }
+    if (outcome.run.exitCode !== 0) {
+      // git writes user-facing failures to stderr OR stdout (e.g. a clean
+      // repo's `git commit` reports "nothing to commit" on stdout).
+      const message = outcome.run.stderr.trim() || outcome.run.stdout.trim()
+      return {
+        ok: false,
+        error: {
+          code: 'git-error',
+          message: message !== '' ? message : `git ${request.action.kind} exited ${String(outcome.run.exitCode)}`,
+        },
+      }
+    }
+    lastStdout = outcome.run.stdout.trim()
+  }
+
+  const snapshot = await snapshotForSession(deps, config, request.sessionId)
+  if (!snapshot.ok) return operationError(snapshot.error)
+  return { ok: true, snapshot: snapshot.value, ...(lastStdout === '' ? {} : { output: lastStdout }) }
+}

package/src/host/core.ts

@@ -89,7 +89,7 @@ function runFailure(result: { readonly timedOut: boolean }, detail: string): Ext
 }
 
 /** Run one command, mapping a spawn-level failure to a snapshot failure. */
-async function runCommand(
+export async function runCommand(
   runner: GitRunner,
   argv: readonly string[],
   cwd: string,
@@ -104,20 +104,18 @@ async function runCommand(
 }
 
 /**
- * Build one frozen GitSnapshot for a session working directory.
- * Command sequence (all read-only; every command after the first runs with
- * the repository root as cwd):
- *   1. `git rev-parse --show-toplevel`      — repo detection (exit 128 → not-a-git-repo)
- *   2. `git branch --show-current`          — null when detached
- *   3. `git rev-parse --short HEAD`         — null + unborn when the repo has no commits
- *   4. `git status --porcelain=v1 -z --branch`
- *   5. `git log -n 5 --format=%H%x1f%h%x1f%s%x1f%an%x1f%aI`
+ * Resolve a session's repository workspace: cwd (live or persisted), the
+ * realpath'd directory, and the git work-tree root via `rev-parse
+ * --show-toplevel`. Shared by the snapshot flow and the operation runner.
  */
-export async function snapshotForSession(
+export type WorkspaceResolution =
+  | { readonly ok: true; readonly cwd: string; readonly root: string }
+  | { readonly ok: false; readonly error: Extract<GitSnapshotResult, { ok: false }>['error'] }
+
+export async function resolveWorkspace(
   deps: SnapshotDeps,
-  config: GitStatusConfig,
   sessionId: string,
-): Promise<GitSnapshotResult> {
+): Promise<WorkspaceResolution> {
   const resolved = await resolveCwd(deps.sessions, sessionId)
   if (!resolved.ok) return { ok: false, error: resolved.error }
 
@@ -149,6 +147,27 @@ export async function snapshotForSession(
   }
   const root = toplevel.run.stdout.trim()
   if (root === '') return { ok: false, error: { code: 'not-a-git-repo' } }
+  return { ok: true, cwd: realCwd, root }
+}
+
+/**
+ * Build one frozen GitSnapshot for a session working directory.
+ * Command sequence (all read-only; every command after the first runs with
+ * the repository root as cwd):
+ *   1. `git rev-parse --show-toplevel`      — repo detection (exit 128 → not-a-git-repo)
+ *   2. `git branch --show-current`          — null when detached
+ *   3. `git rev-parse --short HEAD`         — null + unborn when the repo has no commits
+ *   4. `git status --porcelain=v1 -z --branch`
+ *   5. `git log -n 5 --format=%H%x1f%h%x1f%s%x1f%an%x1f%aI`
+ */
+export async function snapshotForSession(
+  deps: SnapshotDeps,
+  config: GitStatusConfig,
+  sessionId: string,
+): Promise<GitSnapshotResult> {
+  const workspace = await resolveWorkspace(deps, sessionId)
+  if (!workspace.ok) return { ok: false, error: workspace.error }
+  const root = workspace.root
 
   const branchRun = await runCommand(deps.run, ['git', 'branch', '--show-current'], root, 'branch', deps.signal)
   if ('failure' in branchRun) return { ok: false, error: branchRun.failure }

package/src/host/index.ts

@@ -1,22 +1,25 @@
 /**
  * dsh-git-ui host half: the `gitInfo` Remote service.
  *
- * Cordis shell only — every behavior lives in `core.ts` behind injected
- * structural faces, so tests never need a cordis runtime. The class is a
- * plugin in its own right (class form), mounted by the bundle patch row with
- * the package name; the gateway exposes `gitInfo/snapshot` through SRC
- * discovery (`typertRemote` binding + `@Remote` marker).
+ * Cordis shell only — every behavior lives in `core.ts`/`actions.ts` behind
+ * injected structural faces, so tests never need a cordis runtime. The class
+ * is a plugin in its own right (class form), mounted by the bundle patch row
+ * with the package name; the gateway exposes `gitInfo/snapshot` and
+ * `gitInfo/run` through SRC discovery (`typertRemote` binding + `@Remote`
+ * marker).
  */
 import { Remote, TypertRemoteService } from '@deepseek-ai/dsh-typert-protocol'
 import type { Context } from '@deepseek-ai/cordis'
 import { realpath, stat } from 'node:fs/promises'
 import { createGitRunner, type SubprocessLike } from './git.ts'
-import { normalizeConfig, snapshotForSession, type GitStatusConfig } from './core.ts'
-import type { GitSnapshotRequest, GitSnapshotResult } from './types.ts'
+import { normalizeConfig, snapshotForSession, type GitStatusConfig, type SnapshotDeps } from './core.ts'
+import { runAction } from './actions.ts'
+import type { GitActionResult, GitActionRequest, GitSnapshotRequest, GitSnapshotResult } from './types.ts'
 
-export type { GitSnapshot, GitSnapshotResult, GitSnapshotFailure, GitSnapshotRequest, GitCommit, GitChange } from './types.ts'
+export type { GitSnapshot, GitSnapshotResult, GitSnapshotFailure, GitSnapshotRequest, GitCommit, GitChange, GitAction, GitActionResult, GitActionRequest } from './types.ts'
 export { normalizeConfig, DEFAULT_CONFIG } from './core.ts'
 export { parseStatusOutput, parseLogOutput, parseBranchOutput } from './parser.ts'
+export { isSafePath, runAction } from './actions.ts'
 
 /** Structural face of a live session header. */
 interface SessionLike {
@@ -33,7 +36,7 @@ interface SessionPersistenceLike {
   inspect(id: string): Promise<{ readonly meta: { readonly cwd?: string } }>
 }
 
-/** The `gitInfo` service: one `snapshot` Remote endpoint. */
+/** The `gitInfo` service: `snapshot` (read) and `run` (management) endpoints. */
 export class GitStatusService extends TypertRemoteService {
   static inject = ['subprocess', 'sessions', 'sessionPersistence']
 
@@ -44,17 +47,17 @@ export class GitStatusService extends TypertRemoteService {
     this.config = normalizeConfig(config)
   }
 
-  @Remote('snapshot')
-  async snapshot(request: GitSnapshotRequest, signal?: AbortSignal): Promise<GitSnapshotResult> {
+  /** Adapter face shared by both endpoints (injected services + runner). */
+  private deps(signal?: AbortSignal): { readonly deps: SnapshotDeps } | { readonly failure: { readonly code: 'git-unavailable'; readonly detail: string } } {
     const subprocess = this.ctx.get('subprocess') as SubprocessLike | undefined
     if (subprocess === undefined) {
-      return { ok: false, error: { code: 'git-unavailable', detail: 'subprocess service unavailable' } }
+      return { failure: { code: 'git-unavailable', detail: 'subprocess service unavailable' } }
     }
     const sessions = this.ctx.get('sessions') as SessionsLike | undefined
     const persistence = this.ctx.get('sessionPersistence') as SessionPersistenceLike | undefined
     const runner = createGitRunner(subprocess, this.config.timeoutMs, this.config.maxStatusBytes)
-    return snapshotForSession(
-      {
+    return {
+      deps: {
         run: runner,
         fs: { realpath, stat },
         sessions: {
@@ -71,9 +74,23 @@ export class GitStatusService extends TypertRemoteService {
         },
         signal,
       },
-      this.config,
-      request.sessionId,
-    )
+    }
+  }
+
+  @Remote('snapshot')
+  async snapshot(request: GitSnapshotRequest, signal?: AbortSignal): Promise<GitSnapshotResult> {
+    const adapted = this.deps(signal)
+    if ('failure' in adapted) return { ok: false, error: adapted.failure }
+    return snapshotForSession(adapted.deps, this.config, request.sessionId)
+  }
+
+  @Remote('run')
+  async run(request: GitActionRequest, signal?: AbortSignal): Promise<GitActionResult> {
+    const adapted = this.deps(signal)
+    if ('failure' in adapted) {
+      return { ok: false, error: { code: 'git-error', message: adapted.failure.detail } }
+    }
+    return runAction(adapted.deps, this.config, request)
   }
 }
 

package/src/host/types.ts

@@ -72,3 +72,42 @@ export type GitChangeStatus =
   | 'untracked'
   | 'conflicted'
   | 'typechange'
+
+/**
+ * One git management operation addressed by the `run` endpoint. Paths are
+ * always repository-relative (as listed in a snapshot's `changes`), never
+ * absolute — the host validates them against the work tree.
+ */
+export type GitAction =
+  | { readonly kind: 'stage'; readonly paths: readonly string[] }
+  | { readonly kind: 'stage-all' }
+  | { readonly kind: 'unstage'; readonly paths: readonly string[] }
+  | { readonly kind: 'unstage-all' }
+  | { readonly kind: 'discard'; readonly paths: readonly string[] }
+  | { readonly kind: 'discard-all' }
+  | {
+    readonly kind: 'commit'
+    readonly message: string
+    /** Commit only these paths (git commit -- <paths> semantics); absent or
+     * empty commits everything already staged. */
+    readonly paths?: readonly string[]
+  }
+
+export type GitOperationErrorCode =
+  | 'session-not-found'
+  | 'cwd-unavailable'
+  | 'path-not-found'
+  | 'not-a-git-repo'
+  | 'invalid-path'
+  | 'git-error'
+  | 'timeout'
+
+export type GitActionResult =
+  | { readonly ok: true; readonly snapshot: GitSnapshot; readonly output?: string }
+  | { readonly ok: false; readonly error: { readonly code: GitOperationErrorCode; readonly message?: string } }
+
+/** Wire request of the `run` endpoint. */
+export interface GitActionRequest {
+  readonly sessionId: string
+  readonly action: GitAction
+}