dsh-client-auto-continue 0.5.2 → 0.5.4

package/src/client/settings-form.ts

@@ -0,0 +1,293 @@
+/**
+ * Staged form model behind the plugin settings card — a self-contained
+ * implementation of the plugin-card store pattern used by the DSH plugin
+ * configuration section.
+ *
+ * A card stages what the user types and writes it only when they save. Each
+ * settings write is a durable, revision-fenced document mutation, so staging
+ * keeps what is on screen exactly what a save would store. A field shows its
+ * effective value — the user layer over the composition layer over the schema
+ * default — and whether the user layer carries it (presence, not value
+ * equality, marks an override).
+ */
+import type { SettingsScope, SnapshotStore } from '@deepseek-ai/dsh-client-runtime/client';
+
+/** The write one field's staged text performs when the card is saved. */
+export type FieldWrite = { kind: 'set'; value: unknown } | { kind: 'clear' };
+
+/** How one field converts between its stored value and its draft text. */
+export interface CardFieldSpec {
+  /** Field name inside the namespace section. */
+  field: string;
+  /** Render a stored value as draft text; the empty string when the section carries none. */
+  format: (value: unknown) => string;
+  /**
+   * The write this draft text stages, or undefined when the text is not a
+   * value this field accepts — which blocks the save rather than discarding it.
+   */
+  parse: (text: string) => FieldWrite | undefined;
+}
+
+/** One field as the card's control renders it. */
+export interface CardFieldState {
+  /** Draft text the control renders. */
+  text: string;
+  /** Whether saving would leave a user-layer entry for this field. */
+  overridden: boolean;
+  /** Whether the draft is not a value this field accepts, which blocks saving. */
+  invalid: boolean;
+}
+
+/** Form state every plugin card shares. */
+export interface CardShell {
+  /** False while the namespace is not served to this client; the card renders nothing. */
+  available: boolean;
+  /** Whether the Host document accepts writes. */
+  writable: boolean;
+  /** Whether the form holds edits that a save would write. */
+  dirty: boolean;
+  /** Whether any staged draft is invalid, which blocks the save. */
+  invalid: boolean;
+  /** Whether a save is crossing the wire. */
+  saving: boolean;
+  /** Whether the last save did not land as staged; cleared by the next edit or save. */
+  failed: boolean;
+}
+
+/** The write actions the card's slot entry injects. */
+export interface CardActions {
+  /** Stage draft text for one field. */
+  edit: (field: string, text: string) => void;
+  /** Stage a clear, so saving lets the field re-inherit the composition layer. */
+  resetField: (field: string) => void;
+  /** Write every staged edit, then re-seed from what the Host accepted. */
+  save: () => void;
+  /** Drop every staged edit. */
+  discard: () => void;
+}
+
+/** A whole-number field. An empty draft clears the field; a non-number or out-of-range draft blocks the save. */
+export function numberField(field: string, min = 0): CardFieldSpec {
+  return {
+    field,
+    format: (value) => (typeof value === 'number' ? String(value) : ''),
+    parse: (text) => {
+      const trimmed = text.trim();
+      if (trimmed === '') return { kind: 'clear' };
+      const parsed = Number(trimmed);
+      if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed < min) return undefined;
+      return { kind: 'set', value: parsed };
+    },
+  };
+}
+
+/** A free-text field. An empty draft clears the field, so emptying the control and saving is the same gesture as resetting it. */
+export function textField(field: string): CardFieldSpec {
+  return {
+    field,
+    format: (value) => (typeof value === 'string' ? value : ''),
+    parse: (text) => {
+      const trimmed = text.trim();
+      return trimmed === '' ? { kind: 'clear' } : { kind: 'set', value: trimmed };
+    },
+  };
+}
+
+/** A boolean field, edited through true/false draft text; an empty draft inherits. */
+export function booleanField(field: string): CardFieldSpec {
+  return {
+    field,
+    format: (value) => (typeof value === 'boolean' ? String(value) : ''),
+    parse: (text) => {
+      const trimmed = text.trim();
+      if (trimmed === '') return { kind: 'clear' };
+      if (trimmed === 'true') return { kind: 'set', value: true };
+      if (trimmed === 'false') return { kind: 'set', value: false };
+      return undefined;
+    },
+  };
+}
+
+/** One field's staged edit. */
+interface StagedEdit {
+  /** Draft text the control renders. */
+  text: string;
+  /** True when this edit clears the field whatever text it shows. */
+  clear: boolean;
+}
+
+/**
+ * Stages one card's edits over one settings namespace and writes them on save.
+ *
+ * The Host is the only authority on whether a value was accepted, so the
+ * outcome is read back from the section rather than predicted here. A save
+ * that did not land keeps its drafts, so the user can correct them instead of
+ * retyping.
+ */
+export class CardForm<T> {
+  private readonly specs: Map<string, CardFieldSpec>;
+  private readonly staged = new Map<string, StagedEdit>();
+  private readonly listeners = new Set<() => void>();
+  private saving = false;
+  private failed = false;
+
+  /**
+   * @param scope - the bound settings scope for this card's namespace.
+   * @param specs - the section fields this card edits.
+   */
+  constructor(
+    private readonly scope: SettingsScope<T>,
+    specs: CardFieldSpec[],
+  ) {
+    this.specs = new Map(specs.map((spec) => [spec.field, spec]));
+    this.scope.subscribe(() => this.publish());
+  }
+
+  /** Publish a projection of this form, rebuilt whenever the scope or a draft changes. */
+  bind<S>(project: () => S, createStore: (init: S) => SnapshotStore<S>): SnapshotStore<S> {
+    const store = createStore(project());
+    this.listeners.add(() => store.set(project()));
+    return store;
+  }
+
+  /** Read the card-level state: what the Host serves, and what a save would do. */
+  shell(): CardShell {
+    const snapshot = this.scope.getSnapshot();
+    return {
+      available: snapshot.status === 'ready',
+      writable: snapshot.writable,
+      dirty: this.plan().length > 0,
+      invalid: this.plan().some((item) => item.run === undefined),
+      saving: this.saving,
+      failed: this.failed,
+    };
+  }
+
+  /** Read one field's state from the effective section and its staged draft. */
+  field(field: string): CardFieldState {
+    const spec = this.specOf(field);
+    const staged = this.staged.get(field);
+    if (staged === undefined) {
+      return {
+        text: spec.format(this.sectionValue(field)),
+        overridden: this.stored(field),
+        invalid: false,
+      };
+    }
+    const write = staged.clear ? { kind: 'clear' as const } : spec.parse(staged.text);
+    return {
+      text: staged.text,
+      overridden: write?.kind === 'set',
+      invalid: write === undefined,
+    };
+  }
+
+  /** The actions the card's slot registration injects. */
+  actions(): CardActions {
+    return {
+      edit: (field, text) => this.stage(field, { text, clear: false }),
+      resetField: (field) => {
+        this.stage(field, { text: this.specOf(field).format(this.baseValue(field)), clear: true });
+      },
+      save: () => void this.save(),
+      discard: () => {
+        if (this.staged.size === 0 && !this.failed) return;
+        this.staged.clear();
+        this.failed = false;
+        this.publish();
+      },
+    };
+  }
+
+  /**
+   * Write every staged edit, then re-seed from what the Host accepted.
+   * @returns settlement after every write and the read-back.
+   */
+  async save(): Promise<void> {
+    const plan = this.plan();
+    const writes = plan.flatMap((item) => (item.run === undefined ? [] : [item.run]));
+    if (plan.length === 0 || this.saving || writes.length !== plan.length) return;
+    // Snapshot the fields this save writes, so edits staged while it is in
+    // flight survive: only the staged keys this save actually wrote are cleared.
+    const fields = new Set(plan.map((item) => item.field));
+    this.saving = true;
+    this.failed = false;
+    this.publish();
+    let landed = true;
+    for (const write of writes) {
+      landed = (await write()) && landed;
+    }
+    if (landed) {
+      for (const field of fields) this.staged.delete(field);
+    }
+    this.saving = false;
+    this.failed = !landed;
+    this.publish();
+  }
+
+  /**
+   * Every staged edit a save would write. An entry whose draft is not a value
+   * its field accepts carries no write: the form is still dirty, and the save
+   * refuses rather than dropping the edit. A staged edit that matches the
+   * effective section is not a write at all.
+   */
+  private plan(): { field: string; run: (() => Promise<boolean>) | undefined }[] {
+    const plan: { field: string; run: (() => Promise<boolean>) | undefined }[] = [];
+    for (const [field, staged] of this.staged) {
+      const spec = this.specOf(field);
+      if (staged.clear) {
+        if (this.stored(field)) plan.push({ field, run: () => this.clear(field) });
+        continue;
+      }
+      if (staged.text === spec.format(this.sectionValue(field))) continue;
+      const write = spec.parse(staged.text);
+      if (write === undefined) plan.push({ field, run: undefined });
+      else if (write.kind === 'clear') plan.push({ field, run: () => this.clear(field) });
+      else plan.push({ field, run: () => this.store(field, write.value) });
+    }
+    return plan;
+  }
+
+  private async clear(field: string): Promise<boolean> {
+    await this.scope.unset(field);
+    return !this.stored(field);
+  }
+
+  private async store(field: string, value: unknown): Promise<boolean> {
+    await this.scope.set(field, value);
+    return this.userLayer()?.[field] === value;
+  }
+
+  private stage(field: string, edit: StagedEdit): void {
+    this.staged.set(field, edit);
+    this.failed = false;
+    this.publish();
+  }
+
+  private specOf(field: string): CardFieldSpec {
+    const spec = this.specs.get(field);
+    if (spec === undefined) throw new Error(`settings card has no field ${field}`);
+    return spec;
+  }
+
+  private sectionValue(field: string): unknown {
+    return (this.scope.getSnapshot().value as Record<string, unknown> | undefined)?.[field];
+  }
+
+  private baseValue(field: string): unknown {
+    return (this.scope.getSnapshot().base as Record<string, unknown> | undefined)?.[field];
+  }
+
+  private userLayer(): Record<string, unknown> | undefined {
+    return this.scope.getSnapshot().user as Record<string, unknown> | undefined;
+  }
+
+  private stored(field: string): boolean {
+    const user = this.userLayer();
+    return user !== undefined && Object.prototype.hasOwnProperty.call(user, field);
+  }
+
+  private publish(): void {
+    for (const listener of this.listeners) listener();
+  }
+}

package/src/client/styles.ts

@@ -0,0 +1,172 @@
+/**
+ * Styles for the auto-continue settings card, injected at factory
+ * materialization so the client module system's style bookkeeping (HMR) owns
+ * them. Uses the DSH design tokens (`--dsw-alias-*`) so the card follows the
+ * active theme.
+ */
+
+const css = `
+.dshAcCard {
+  border: 1px solid var(--dsw-alias-border-l2);
+  background: var(--dsw-alias-bg-layer-3);
+  border-radius: 12px;
+  list-style: none;
+  transition: border-color .16s, background .16s;
+}
+.dshAcCard:hover { border-color: var(--dsw-alias-label-dimmed); }
+.dshAcCardOpen {
+  background: var(--dsw-alias-bg-layer-2);
+  border-color: var(--dsw-alias-label-dimmed);
+}
+.dshAcHeader {
+  appearance: none;
+  width: 100%;
+  font: inherit;
+  color: inherit;
+  text-align: left;
+  cursor: pointer;
+  background: none;
+  border: 0;
+  border-radius: 12px;
+  align-items: center;
+  gap: 12px;
+  padding: 14px 16px;
+  display: flex;
+}
+.dshAcHeader:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: -2px; }
+.dshAcHeadText { flex-direction: column; flex: 1; gap: 4px; min-width: 0; display: flex; }
+.dshAcName { color: var(--dsw-alias-label-primary); font-size: 15px; font-weight: 600; line-height: 1.4; }
+.dshAcDescription { color: var(--dsw-alias-label-tertiary); font-size: 13px; line-height: 1.5; }
+.dshAcChevron { color: var(--dsw-alias-label-tertiary); flex: none; transition: transform .16s; }
+.dshAcChevronOpen { transform: rotate(180deg); }
+.dshAcBody { border-top: 1px solid var(--dsw-alias-border-l2); margin: 0 16px; padding-bottom: 8px; }
+.dshAcReadOnly { color: var(--dsw-alias-label-tertiary); margin: 12px 0 0; font-size: 12px; line-height: 1.5; }
+.dshAcPending {
+  white-space: nowrap;
+  background: var(--dsw-alias-bg-module-platform);
+  color: var(--dsw-alias-label-secondary);
+  border-radius: 999px;
+  flex: none;
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 17px;
+}
+.dshAcFooter {
+  border-top: 1px solid var(--dsw-alias-border-l2);
+  justify-content: flex-end;
+  align-items: center;
+  gap: 8px;
+  padding: 12px 0 4px;
+  display: flex;
+}
+.dshAcFailed { min-width: 0; color: var(--dsw-alias-label-error); flex: 1; margin: 0; font-size: 12px; line-height: 1.5; }
+.dshAcDiscard, .dshAcSave {
+  appearance: none;
+  font: inherit;
+  cursor: pointer;
+  border: 1px solid transparent;
+  border-radius: 8px;
+  padding: 5px 14px;
+  font-size: 13px;
+  line-height: 1.5;
+}
+.dshAcDiscard { border-color: var(--dsw-alias-border-l2); color: var(--dsw-alias-label-secondary); background: none; }
+.dshAcDiscard:hover:not(:disabled) { color: var(--dsw-alias-label-primary); border-color: var(--dsw-alias-label-dimmed); }
+.dshAcSave { background: var(--dsw-alias-label-primary); color: var(--dsw-alias-bg-layer-3); }
+.dshAcDiscard:disabled, .dshAcSave:disabled { opacity: .4; cursor: default; }
+.dshAcDiscard:focus-visible, .dshAcSave:focus-visible { outline: 2px solid var(--dsw-alias-brand-primary); outline-offset: 1px; }
+.dshAcField { flex-direction: column; gap: 6px; padding: 12px 0; display: flex; }
+.dshAcField + .dshAcField { border-top: 1px solid var(--dsw-alias-border-l2); }
+.dshAcHead { align-items: center; gap: 8px; display: flex; }
+.dshAcLabel { min-width: 0; color: var(--dsw-alias-label-primary); flex: 1; font-size: 13px; font-weight: 500; line-height: 1.5; }
+.dshAcBadges { align-items: center; gap: 8px; display: inline-flex; }
+.dshAcBadge {
+  white-space: nowrap;
+  background: var(--dsw-alias-bg-module-platform);
+  color: var(--dsw-alias-label-secondary);
+  border-radius: 999px;
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 17px;
+}
+.dshAcReset {
+  font: inherit;
+  color: var(--dsw-alias-label-secondary);
+  cursor: pointer;
+  background: none;
+  border: none;
+  padding: 0;
+  font-size: 12px;
+  line-height: 1.5;
+}
+.dshAcReset:hover:not(:disabled) { color: var(--dsw-alias-label-primary); }
+.dshAcReset:disabled { cursor: default; }
+.dshAcInput {
+  border: 1px solid var(--dsw-alias-border-l2);
+  background: var(--dsw-alias-bg-layer-3);
+  height: 34px;
+  font: inherit;
+  color: var(--dsw-alias-label-primary);
+  border-radius: 8px;
+  padding: 0 12px;
+  font-size: 13px;
+  line-height: 1.5;
+}
+.dshAcInput:focus-visible { border-color: var(--dsw-alias-brand-primary); outline: none; }
+.dshAcInput:disabled { color: var(--dsw-alias-label-tertiary); cursor: default; }
+.dshAcInputInvalid { border-color: var(--dsw-alias-label-error); }
+.dshAcSelect {
+  border: 1px solid var(--dsw-alias-border-l2);
+  background: var(--dsw-alias-bg-layer-3);
+  height: 34px;
+  font: inherit;
+  color: var(--dsw-alias-label-primary);
+  border-radius: 8px;
+  padding: 0 8px;
+  font-size: 13px;
+  line-height: 1.5;
+}
+.dshAcSelect:focus-visible { border-color: var(--dsw-alias-brand-primary); outline: none; }
+.dshAcSelect:disabled { color: var(--dsw-alias-label-tertiary); cursor: default; }
+.dshAcInvalid { color: var(--dsw-alias-label-error); margin: 0; font-size: 12px; line-height: 1.5; }
+.dshAcHint { color: var(--dsw-alias-label-tertiary); margin: 0; font-size: 12px; line-height: 1.5; }
+.dshAcPanel { border-top: 1px solid var(--dsw-alias-border-l2); flex-direction: column; gap: 8px; padding: 12px 0; display: flex; }
+.dshAcPanelHead { align-items: center; gap: 8px; display: flex; }
+.dshAcPanelTitle { color: var(--dsw-alias-label-primary); flex: 1; font-size: 13px; font-weight: 600; line-height: 1.5; }
+.dshAcStats { gap: 4px 16px; margin: 0; grid-template-columns: repeat(2, minmax(0, 1fr)); display: grid; }
+.dshAcStats > div { justify-content: space-between; gap: 8px; display: flex; }
+.dshAcStats dt { color: var(--dsw-alias-label-secondary); font-size: 12px; line-height: 1.5; }
+.dshAcStats dd { color: var(--dsw-alias-label-primary); margin: 0; font-size: 12px; font-weight: 600; line-height: 1.5; }
+.dshAcCodes { flex-wrap: wrap; align-items: center; gap: 6px; display: flex; }
+.dshAcCode {
+  white-space: nowrap;
+  background: var(--dsw-alias-bg-module-platform);
+  color: var(--dsw-alias-label-secondary);
+  border-radius: 999px;
+  padding: 1px 8px;
+  font-size: 11px;
+  font-weight: 500;
+  line-height: 17px;
+}
+.dshAcPauseList { flex-direction: column; gap: 4px; margin: 0; padding: 0; list-style: none; display: flex; }
+.dshAcPauseList li { align-items: center; gap: 8px; display: flex; }
+.dshAcPauseId {
+  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
+  color: var(--dsw-alias-label-primary);
+  font-size: 12px;
+  line-height: 1.5;
+}
+`;
+
+/** Inject the stylesheet once; a no-op outside a browser environment. */
+export function injectStyles(): void {
+  if (typeof document === 'undefined') return;
+  if (document.querySelector('style[data-plugin-css="auto-continue/card"]') !== null) return;
+  const tag = document.createElement('style');
+  tag.dataset.plugin = 'dsh-client-auto-continue';
+  tag.dataset.pluginCss = 'auto-continue/card';
+  tag.textContent = css;
+  document.head.appendChild(tag);
+}

package/src/index.ts

@@ -0,0 +1,62 @@
+/**
+ * Host half of the auto-continue plugin: registers the `auto-continue`
+ * settings namespace so the browser half's settings card can edit it and the
+ * engine can read it. No other host-side behavior.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import z from '@deepseek-ai/schemastery';
+import { settingsNamespace } from '@deepseek-ai/dsh-settings';
+// Type-only: pulls the `ctx.settings` Context augmentation from dsh-settings.
+import type {} from '@deepseek-ai/dsh-settings';
+
+/** Settings namespace of the auto-continue plugin (lowercase kebab-case). */
+export const AUTO_CONTINUE_NS = 'auto-continue';
+
+/** Wire schema of the auto-continue section; defaults are the plugin's built-in values. */
+export const AutoContinueSchema = z.object({
+  /** Text automatically sent after an interruption. */
+  continueText: z.string().default('继续'),
+  /** Text sent when the output token ceiling is reached (same placeholders as `continueText`). */
+  continueTextMaxTokens: z.string().default('继续'),
+  /** Grace period after an interruption before auto-sending (ms). */
+  graceMs: z.natural().default(3000),
+  /** Minimum interval between two auto-continues per session (ms). */
+  cooldownMs: z.natural().default(20000),
+  /** Max consecutive auto-continues per session before stopping. */
+  maxConsecutive: z.natural().min(1).default(3),
+  /** Scan recently interrupted sessions on page load / reconnect. */
+  scanOnBoot: z.boolean().default(true),
+  /** Max sessions the scan checks (most recently updated). */
+  scanLimit: z.natural().min(1).default(8),
+  /** Scan only considers interruptions inside this window (ms). */
+  freshMs: z.natural().default(15 * 60 * 1000),
+  /** Delay before scanning after a reconnect (ms). */
+  reconnectScanDelayMs: z.natural().default(5000),
+  /** SSE reconnect backoff (ms). */
+  reconnectBackoffMs: z.natural().default(3000),
+  /** Log `[auto-continue]` lines to the browser console. */
+  verbose: z.boolean().default(true),
+  /** Classify failures: auto-continue transient errors only; permanent ones are skipped and notified. */
+  classify: z.boolean().default(true),
+  /** Cooldown multiplier per consecutive failure (adaptive backoff). */
+  backoffFactor: z.natural().min(1).default(2),
+  /** Cap on the effective backoff interval (ms). */
+  backoffMaxMs: z.natural().default(300000),
+  /** Show browser notifications for auto-continue events. */
+  notify: z.boolean().default(false),
+  /** Globally pause auto-continue: no live or scan send. */
+  paused: z.boolean().default(false),
+});
+
+/**
+ * Plugin body: register the settings namespace when a settings provider is
+ * composed. Changes apply live — the browser half observes the scope.
+ * @param ctx - host plugin context.
+ */
+export function apply(ctx: Context): void {
+  ctx.inject(['settings'], (settingsCtx) => {
+    settingsCtx.settings.register(settingsNamespace(AUTO_CONTINUE_NS), AutoContinueSchema, {
+      applies: 'live',
+    });
+  });
+}

package/tsconfig.build.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": false,
+    "emitDeclarationOnly": true,
+    "declaration": true,
+    "outDir": "lib/types",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}

package/tsconfig.json

@@ -0,0 +1,29 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "lib": [
+      "ES2020",
+      "DOM",
+      "DOM.Iterable"
+    ],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "isolatedModules": true,
+    "forceConsistentCasingInFileNames": true,
+    "noUncheckedIndexedAccess": true,
+    "types": [
+      "react"
+    ],
+    "allowImportingTsExtensions": true,
+    "rewriteRelativeImportExtensions": true
+  },
+  "include": [
+    "src/**/*.ts",
+    "src/**/*.tsx"
+  ]
+}