@deepseek-harness-tui/dsh-tui 0.9.0 → 0.9.2

package/lib/types/utils/mentions.d.ts

@@ -5,14 +5,31 @@
  * or after whitespace) — `hello@world` never triggers. The token body is
  * either a run of non-whitespace characters (`@src/a.ts`) or a double-quoted
  * path (`@"my dir/a.ts"`, for paths containing spaces).
+ *
+ * A token may carry a trailing line-range suffix (issue #359, Claude Code
+ * parity): `@src/a.ts#L12` / `@src/a.ts#L12-14` (also after a quoted body:
+ * `@"my dir/a.ts"#L3-5`). The suffix must anchor at the token END and match
+ * `#L<digits>` / `#L<digits>-<digits>` exactly, so legal filenames that merely
+ * contain `#` (`report#L12.md`) never trip it; a range like `#L14-12` is
+ * rejected (kept as a literal path). Resolution order is strip-first: the
+ * suffix-stripped `path` is tried, and the caller may fall back to `literal`
+ * (the typed body, suffix intact) when that misses.
  */
 export interface MentionToken {
     /** Start index of the `@` in the source text. */
     start: number;
-    /** End index (exclusive) of the whole token, quote included. */
+    /** End index (exclusive) of the whole token, quote and suffix included. */
     end: number;
-    /** The referenced path as typed (unquoted, no leading `@`). */
+    /** The referenced path as typed (unquoted, no leading `@`, suffix stripped). */
     path: string;
+    /** Present only when a line suffix was stripped: the typed body verbatim
+     * (unquoted, suffix intact) — the literal fallback path for resolution. */
+    literal?: string;
+    /** Inclusive 1-based first line of the `#L` suffix, when present. */
+    startLine?: number;
+    /** Inclusive 1-based last line of the `#L` suffix; equals `startLine`
+     * for the single-line form. */
+    endLine?: number;
 }
 /** Extract every `@` mention in `text` (typed order, duplicates kept out). */
 export declare function extractMentions(text: string): MentionToken[];
@@ -21,10 +38,16 @@ export declare function extractMentions(text: string): MentionToken[];
  * that starts at or before the caret with the caret inside it. Used by the
  * prompt's completion trigger so `@` works mid-message, not only at the
  * start of the input.
+ *
+ * `query` is the PATH portion only (a `#L12-14` suffix never leaks into
+ * it) and `pathEnd` marks where that portion ends, so completing a token
+ * like `@src/a.ts#L12` matches on `src/a.ts` and replaces up to (not past)
+ * the `#` — the typed line range survives acceptance.
  */
 export declare function mentionAtCaret(value: string, cursor: number): {
     start: number;
     end: number;
     query: string;
+    pathEnd?: number;
 } | undefined;
 //# sourceMappingURL=mentions.d.ts.map

package/lib/types/utils/mentions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../../../src/utils/mentions.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;IACb,gEAAgE;IAChE,GAAG,EAAE,MAAM,CAAA;IACX,+DAA+D;IAC/D,IAAI,EAAE,MAAM,CAAA;CACb;AAQD,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CA8B5D;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAe3D"}
+{"version":3,"file":"mentions.d.ts","sourceRoot":"","sources":["../../../src/utils/mentions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,MAAM,WAAW,YAAY;IAC3B,iDAAiD;IACjD,KAAK,EAAE,MAAM,CAAA;IACb,2EAA2E;IAC3E,GAAG,EAAE,MAAM,CAAA;IACX,gFAAgF;IAChF,IAAI,EAAE,MAAM,CAAA;IACZ;+EAC2E;IAC3E,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;mCAC+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAA;CACjB;AAoCD,8EAA8E;AAC9E,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,EAAE,CA+C5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAkB7E"}

package/lib/types/utils/mentions.js

@@ -5,11 +5,43 @@
  * or after whitespace) — `hello@world` never triggers. The token body is
  * either a run of non-whitespace characters (`@src/a.ts`) or a double-quoted
  * path (`@"my dir/a.ts"`, for paths containing spaces).
+ *
+ * A token may carry a trailing line-range suffix (issue #359, Claude Code
+ * parity): `@src/a.ts#L12` / `@src/a.ts#L12-14` (also after a quoted body:
+ * `@"my dir/a.ts"#L3-5`). The suffix must anchor at the token END and match
+ * `#L<digits>` / `#L<digits>-<digits>` exactly, so legal filenames that merely
+ * contain `#` (`report#L12.md`) never trip it; a range like `#L14-12` is
+ * rejected (kept as a literal path). Resolution order is strip-first: the
+ * suffix-stripped `path` is tried, and the caller may fall back to `literal`
+ * (the typed body, suffix intact) when that misses.
  */
 /** True when `ch` delimits a token (whitespace). Path separators and the
  *  quote char are ordinary token characters on every platform — Windows
  *  backslash paths must survive both caret tracking and submission. */
 const isBoundary = (ch) => ch === undefined || /\s/.test(ch);
+/** Line-suffix shape: `#L7` or `#L7-9`, anchored at the token end. */
+const LINE_SUFFIX = /#L(\d+)(?:-(\d+))?$/;
+/**
+ * Split a trailing `#L7` / `#L7-9` suffix off an unquoted token body.
+ * Returns undefined when there is no suffix or the suffix is malformed
+ * (`#L0`, `#L9-7`, bare `#L12` with an empty path) — the caller then treats
+ * the body as a plain literal path, exactly as before issue #359.
+ */
+function splitLineSuffix(raw) {
+    const match = LINE_SUFFIX.exec(raw);
+    if (match === null)
+        return undefined;
+    const path = raw.slice(0, match.index);
+    if (path === '')
+        return undefined;
+    const startLine = Number(match[1]);
+    const endLine = match[2] === undefined ? startLine : Number(match[2]);
+    if (!Number.isInteger(startLine) || !Number.isInteger(endLine))
+        return undefined;
+    if (startLine < 1 || endLine < startLine)
+        return undefined;
+    return { path, literal: raw, startLine, endLine };
+}
 /** Extract every `@` mention in `text` (typed order, duplicates kept out). */
 export function extractMentions(text) {
     const tokens = [];
@@ -26,22 +58,41 @@ export function extractMentions(text) {
             const close = text.indexOf('"', at + 2);
             if (close === -1)
                 continue; // unterminated quote — not a mention
-            const path = text.slice(at + 2, close);
-            if (path && !seen.has(path)) {
-                seen.add(path);
-                tokens.push({ start: at, end: close + 1, path });
+            const quoted = text.slice(at + 2, close);
+            // `#L` suffix may follow the closing quote and extends the token.
+            let end = close + 1;
+            let range;
+            if (quoted !== '' && text[close + 1] === '#') {
+                let suffixEnd = close + 1;
+                while (suffixEnd < text.length && !isBoundary(text[suffixEnd]))
+                    suffixEnd++;
+                // splitLineSuffix expects `path + suffix`; feeding it the quoted body
+                // plus the tail yields path === quoted and the typed literal.
+                range = splitLineSuffix(quoted + text.slice(close + 1, suffixEnd));
+                if (range !== undefined)
+                    end = suffixEnd;
             }
-            index = close + 1;
+            const key = text.slice(at, end);
+            if (quoted !== '' && !seen.has(key)) {
+                seen.add(key);
+                tokens.push(range === undefined
+                    ? { start: at, end, path: quoted }
+                    : { start: at, end, path: quoted, literal: `${quoted}${text.slice(close + 1, end)}`, startLine: range.startLine, endLine: range.endLine });
+            }
+            index = end;
             continue;
         }
         let end = at + 1;
         while (end < text.length && !isBoundary(text[end]))
             end++;
-        const path = text.slice(at + 1, end);
+        const raw = text.slice(at + 1, end);
         // A bare `@` or another trigger char (`@@`) carries no path.
-        if (path && !path.startsWith('@') && !seen.has(path)) {
-            seen.add(path);
-            tokens.push({ start: at, end, path });
+        if (raw && !raw.startsWith('@') && !seen.has(raw)) {
+            seen.add(raw);
+            const range = splitLineSuffix(raw);
+            tokens.push(range === undefined
+                ? { start: at, end, path: raw }
+                : { start: at, end, path: range.path, literal: range.literal, startLine: range.startLine, endLine: range.endLine });
         }
     }
     return tokens;
@@ -51,6 +102,11 @@ export function extractMentions(text) {
  * that starts at or before the caret with the caret inside it. Used by the
  * prompt's completion trigger so `@` works mid-message, not only at the
  * start of the input.
+ *
+ * `query` is the PATH portion only (a `#L12-14` suffix never leaks into
+ * it) and `pathEnd` marks where that portion ends, so completing a token
+ * like `@src/a.ts#L12` matches on `src/a.ts` and replaces up to (not past)
+ * the `#` — the typed line range survives acceptance.
  */
 export function mentionAtCaret(value, cursor) {
     // Token start: scan back from the caret to the previous boundary.
@@ -70,5 +126,8 @@ export function mentionAtCaret(value, cursor) {
     let end = cursor;
     while (end < value.length && !isBoundary(value[end]))
         end++;
-    return { start, end, query: value.slice(start + 1, cursor) };
+    const queryEnd = Math.min(cursor, end);
+    const range = splitLineSuffix(value.slice(start + 1, end));
+    const pathEnd = range === undefined ? end : start + 1 + range.path.length;
+    return { start, end, query: value.slice(start + 1, Math.min(queryEnd, pathEnd)), pathEnd: range === undefined ? undefined : pathEnd };
 }

package/lib/types/utils/openExternal.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Windows `start` via cmd.exe: `start "" "<target>"` (the empty quoted
+ * title is mandatory — start would otherwise treat a quoted target as the
+ * window title). Exported for tests: assembly is pure.
+ */
+export declare function buildWin32StartSpawn(target: string): {
+    file: string;
+    args: string[];
+    verbatim: true;
+    detach: true;
+};
+/** Whether `target` exists on disk as a directory (decides the open
+ *  channel: folders bypass the ShellExecute verb and go through the
+ *  Shell.Application COM API). Never throws. */
+export declare function isDirectory(target: string): boolean;
+/**
+ * The Windows spawn descriptor for opening `target` (pure, testable):
+ * directories go through `powershell (New-Object -ComObject
+ * Shell.Application).Open('<dir>')`, everything else (files, URLs) through
+ * `start`. Explorer's single-instance forwarding silently swallows
+ * "open folder" requests on many systems (diagnosed in the field: `start`,
+ * raw explorer, and `/select,` all dead while the COM API works), so the
+ * COM channel is the reliable folder opener; single quotes in the path are
+ * doubled for the PowerShell literal. The COM descriptor also carries
+ * `detach: false` — a DETACHED_PROCESS (console-less) PowerShell silently
+ * drops the Shell.Application Open call, so the channel only works with
+ * `windowsHide` (CREATE_NO_WINDOW) alone (field-diagnosed spawn matrix:
+ * detached+hide → dead, hide-only → works; start keeps working detached).
+ */
+export declare function buildWin32OpenSpawn(target: string): {
+    file: string;
+    args: string[];
+    verbatim: boolean;
+    detach: boolean;
+};
+/** Open a URL, file or directory with the platform's default handler. */
+export declare function openExternal(target: string): void;
+/** Open a file with its associated application (openExternal with a file). */
+export declare function openFile(path: string): void;
+/**
+ * Open the folder containing `filePath` in the platform file manager.
+ *
+ * Windows and Linux open the parent DIRECTORY through openExternal —
+ * Windows routes folders through the Shell.Application COM channel (see
+ * buildWin32OpenSpawn). macOS uses `open -R` to select the file, degrading
+ * to the folder when the file is gone. No-op when neither the file nor its
+ * parent exists (a stale/hallucinated path must not spawn error dialogs).
+ */
+export declare function revealInFileManager(filePath: string): void;
+//# sourceMappingURL=openExternal.d.ts.map

package/lib/types/utils/openExternal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openExternal.d.ts","sourceRoot":"","sources":["../../../src/utils/openExternal.ts"],"names":[],"mappings":"AAgEA;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,IAAI,CAAC;IAAC,MAAM,EAAE,IAAI,CAAA;CAAE,CAQnH;AAED;;gDAEgD;AAChD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAMnD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAE,CAWxH;AAED,yEAAyE;AACzE,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAqBjD;AAED,8EAA8E;AAC9E,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAE3C;AAED;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,IAAI,CAgB1D"}

package/lib/types/utils/openExternal.js

@@ -0,0 +1,170 @@
+/**
+ * Open URLs, files and folders with the platform's default handler, fully
+ * detached from the TUI process (fire-and-forget: no stdio pipes, no wait,
+ * child unref'd so the TUI can exit without waiting for the handler).
+ *
+ * Launch strategy per platform:
+ * - Windows files/URLs: `start` is a cmd.exe builtin, so everything goes
+ *   through `$comspec /d /s /c start "" "<target>"` using the vendored
+ *   cross-spawn quoting (shellQuote.ts) with windowsVerbatimArguments —
+ *   the same protocol externalEditor.ts uses for .cmd shims.
+ * - Windows DIRECTORIES: `powershell (New-Object -ComObject
+ *   Shell.Application).Open('<dir>')`. Explorer's single-instance
+ *   forwarding silently swallows "open folder" requests on many systems
+ *   (field-diagnosed: `start`, raw explorer and `/select,` all dead while
+ *   the COM API works), so folders bypass ShellExecute entirely. This
+ *   powershell child must NOT be spawned detached: libuv maps
+ *   `detached: true` to DETACHED_PROCESS (a console-less process) and in
+ *   that state the Shell.Application Open call silently does nothing
+ *   (field-diagnosed via spawn matrix: detached+hide dead, hide-only
+ *   works) — `windowsHide` alone (CREATE_NO_WINDOW) keeps it invisible
+ *   AND functional.
+ * - macOS: `open` (reveal adds `-R`).
+ * - Linux/other: `xdg-open`.
+ */
+import { spawn } from 'node:child_process';
+import { dirname } from 'node:path';
+import { existsSync, statSync } from 'node:fs';
+import { cmdEscapeArgument } from './shellQuote.js';
+import { logError } from './log.js';
+/**
+ * Spawn a fire-and-forget child: no stdio pipes, no wait, unref'd so the
+ * TUI can exit without waiting for the handler. On Windows `detach`
+ * controls the DETACHED_PROCESS flag — it must stay false for the
+ * Shell.Application COM channel (console-less PowerShell swallows the
+ * Open call; see buildWin32OpenSpawn). Failures are logged, never
+ * thrown — an unopenable target (missing handler, sandboxed desktop)
+ * must not disturb the TUI. `onError` lets callers degrade (e.g.
+ * reveal → open parent folder).
+ */
+function spawnDetached(file, args, opts = {}) {
+    const { verbatim = false, detach = true, onError } = opts;
+    try {
+        const child = spawn(file, [...args], {
+            stdio: 'ignore',
+            detached: detach,
+            windowsHide: true,
+            windowsVerbatimArguments: verbatim,
+        });
+        child.on('error', error => {
+            logError(error);
+            onError?.();
+        });
+        child.unref();
+    }
+    catch (error) {
+        logError(error);
+        onError?.();
+    }
+}
+/**
+ * Windows `start` via cmd.exe: `start "" "<target>"` (the empty quoted
+ * title is mandatory — start would otherwise treat a quoted target as the
+ * window title). Exported for tests: assembly is pure.
+ */
+export function buildWin32StartSpawn(target) {
+    const line = ['start', cmdEscapeArgument(''), cmdEscapeArgument(target)].join(' ');
+    return {
+        file: process.env.ComSpec || 'cmd.exe',
+        args: ['/d', '/s', '/c', `"${line}"`],
+        verbatim: true,
+        detach: true,
+    };
+}
+/** Whether `target` exists on disk as a directory (decides the open
+ *  channel: folders bypass the ShellExecute verb and go through the
+ *  Shell.Application COM API). Never throws. */
+export function isDirectory(target) {
+    try {
+        return statSync(target).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * The Windows spawn descriptor for opening `target` (pure, testable):
+ * directories go through `powershell (New-Object -ComObject
+ * Shell.Application).Open('<dir>')`, everything else (files, URLs) through
+ * `start`. Explorer's single-instance forwarding silently swallows
+ * "open folder" requests on many systems (diagnosed in the field: `start`,
+ * raw explorer, and `/select,` all dead while the COM API works), so the
+ * COM channel is the reliable folder opener; single quotes in the path are
+ * doubled for the PowerShell literal. The COM descriptor also carries
+ * `detach: false` — a DETACHED_PROCESS (console-less) PowerShell silently
+ * drops the Shell.Application Open call, so the channel only works with
+ * `windowsHide` (CREATE_NO_WINDOW) alone (field-diagnosed spawn matrix:
+ * detached+hide → dead, hide-only → works; start keeps working detached).
+ */
+export function buildWin32OpenSpawn(target) {
+    if (isDirectory(target)) {
+        const literal = target.replace(/'/g, "''");
+        return {
+            file: 'powershell.exe',
+            args: ['-NoProfile', '-Command', `(New-Object -ComObject Shell.Application).Open('${literal}')`],
+            verbatim: false,
+            detach: false,
+        };
+    }
+    return buildWin32StartSpawn(target);
+}
+/** Open a URL, file or directory with the platform's default handler. */
+export function openExternal(target) {
+    if (target === '')
+        return;
+    if (process.platform === 'win32') {
+        const cmd = buildWin32OpenSpawn(target);
+        // If the primary channel cannot even spawn (e.g. PowerShell missing on
+        // an exotic system), fall back to `start` — reliable on healthy boxes.
+        spawnDetached(cmd.file, cmd.args, {
+            verbatim: cmd.verbatim,
+            detach: cmd.detach,
+            onError: () => {
+                if (cmd.file !== (process.env.ComSpec || 'cmd.exe')) {
+                    const fb = buildWin32StartSpawn(target);
+                    spawnDetached(fb.file, fb.args, { verbatim: fb.verbatim });
+                }
+            },
+        });
+    }
+    else if (process.platform === 'darwin') {
+        spawnDetached('open', [target]);
+    }
+    else {
+        spawnDetached('xdg-open', [target]);
+    }
+}
+/** Open a file with its associated application (openExternal with a file). */
+export function openFile(path) {
+    openExternal(path);
+}
+/**
+ * Open the folder containing `filePath` in the platform file manager.
+ *
+ * Windows and Linux open the parent DIRECTORY through openExternal —
+ * Windows routes folders through the Shell.Application COM channel (see
+ * buildWin32OpenSpawn). macOS uses `open -R` to select the file, degrading
+ * to the folder when the file is gone. No-op when neither the file nor its
+ * parent exists (a stale/hallucinated path must not spawn error dialogs).
+ */
+export function revealInFileManager(filePath) {
+    if (filePath === '')
+        return;
+    const dir = dirname(filePath);
+    if (process.platform === 'darwin') {
+        if (existsSync(filePath)) {
+            spawnDetached('open', ['-R', filePath], {
+                onError: () => {
+                    if (existsSync(dir))
+                        openExternal(dir);
+                },
+            });
+            return;
+        }
+        if (existsSync(dir))
+            openExternal(dir);
+        return;
+    }
+    if (existsSync(dir))
+        openExternal(dir);
+}

package/node_modules/@deepseek-harness-tui/dsh-auth/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ccch1mneyyy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/@deepseek-harness-tui/dsh-auth/README.md

@@ -0,0 +1,140 @@
+# @deepseek-harness-tui/dsh-auth
+
+> Subscription OAuth sign-in for [dsh-TUI](https://github.com/ccch1mneyyy/dsh-TUI) and
+> [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness)
+
+Use your **ChatGPT (Plus/Pro)**, **Claude (Pro/Max)** and **SuperGrok / X Premium**
+subscriptions as model providers — sign in with the official account, no API
+keys, and **no dsh source patch**. This plugin is developed alongside (and
+bundled into) [dsh-TUI](https://github.com/ccch1mneyyy/dsh-TUI), the
+Claude Code style terminal front door for DeepSeek Harness; it also installs
+standalone into any dsh profile.
+
+```
+dsh-tui → /provider → 订阅账号登录（OAuth）→ sign in   ← the TUI integration
+          /auth login openai-codex                     ← the plugin command
+          /model → OpenAI Codex → gpt-5.6-sol          ← routes & models
+```
+
+**Status: experimental (M1).** The OAuth flows themselves are
+[pi-ai](https://www.npmjs.com/package/@earendil-works/pi-ai)'s shipped
+implementations (device-code and loopback callback included); this plugin
+adds the hosting: credential storage, automatic token refresh, adapter
+registration, and a login surface over the `userQuestions` seam that works in
+the TUI, the web client, and refuses cleanly on headless hosts.
+
+## Install
+
+**With dsh-TUI** — nothing to do: dsh-auth ships inside the dsh-tui package
+(bundled dependency). Update dsh-tui and the `/provider` wizard gains its
+subscription sign-in branch automatically.
+
+**Standalone, into any dsh profile:**
+
+```sh
+dsh plugin --profile <name> add @deepseek-harness-tui/dsh-auth
+```
+
+Then restart the host; `/` lists `auth`, and every model picker gains the
+signed-in providers' catalogs (credential-gated — see below).
+
+## What it does
+
+- Mounts the pi-ai catalog providers that ship OAuth flows as `llm` registry
+  routes: `openai-codex`, `anthropic`, `xai`. **Models appear in a picker
+  only after that provider is signed in** (credential-gated listing) — sign
+  in and the catalog appears, sign out and it disappears; model ids already
+  saved in sessions stay resolvable either way.
+- `/auth login [provider]` runs the provider's OAuth flow interactively. The
+  waiting panel behaves the way pi's host does: the authorization URL is
+  **opened in your browser automatically** (never hand-copied — the URL is
+  hundreds of characters and wrap artifacts corrupt its `redirect_uri`),
+  and the panel offers *Copy authorization link* / *Open browser again* /
+  *Cancel sign-in*. Device-code flows open the verification page and make
+  the short code the copy target. OpenAI Codex also offers a device-code
+  login method — the most robust path on headless or locked-down machines
+  (no localhost:1455 callback needed).
+- Stored access tokens refresh automatically before each request, serialized
+  per provider under the credential store's lock — concurrent requests never
+  double-refresh a rotated token.
+- `/auth status` / `/auth logout <provider>`; the `ctx.dshAuth` service
+  exposes the same api for UIs (the dsh-tui `/provider` wizard and `/login`
+  ride it).
+
+## Usage
+
+```
+/auth                          # status: which providers are signed in
+/auth login                    # pick a provider interactively
+/auth login openai-codex       # ChatGPT (Plus/Pro)
+/auth login anthropic          # Claude (Pro/Max)
+/auth login xai                # SuperGrok / X Premium
+/auth logout anthropic
+```
+
+Model requests against a provider you have not signed in to fail loudly with
+the `/auth login <provider>` hint — never silently.
+
+## Configuration
+
+```yaml
+- id: dsh-auth
+  name: '@deepseek-harness-tui/dsh-auth'
+  config:
+    providers: [openai-codex, anthropic, xai]   # any non-empty subset
+    # credentialsFile: /secure/path/credentials.json
+```
+
+- `credentialsFile` defaults to `$DSH_HOME/dsh-auth/credentials.json`
+  (`~/.dsh/dsh-auth/credentials.json`), overridable with the
+  `DSH_AUTH_CREDENTIALS` environment variable. The directory is created
+  `0700`, the file `0600` (best-effort on Windows), and every write is
+  atomic (temp file + rename).
+- A route another adapter family already owns — an `llm-pi-ai` settings
+  profile naming the same provider — is refused by the registry; the plugin
+  logs the refusal and mounts the remaining routes. Keep one provider on one
+  adapter.
+
+## Security notes
+
+- The credential file holds **long-lived refresh tokens**. It is never
+  logged, never echoed through status surfaces (`/auth status` shows expiry
+  metadata only), and a corrupt file fails loudly instead of being
+  overwritten.
+- Secret prompts warn that terminal input is not masked on this surface.
+- Login refuses to run where no interactive surface is registered (no
+  browser/GUI assumptions — remote and headless hosts get a clear error,
+  per the ecosystem spec's remote-determinism rule, TUI-RUN-001).
+- Subscription authentication and API-key access are different products:
+  this plugin uses each provider's subscription backend only (ChatGPT Codex
+  backend for OpenAI, Claude Pro/Max for Anthropic) and does not turn a
+  subscription into a general-purpose API credential.
+
+## Development
+
+```sh
+pnpm install
+pnpm verify     # build + headless smoke (credential store, refresh
+                # serialization, prompt bridging, gating, service api)
+```
+
+The smoke suite runs without cordis or a harness: the pure modules are
+exercised directly. Real end-to-end login needs an interactive host
+(dsh-tui) and is verified manually per release. The plugin is developed in
+the [dsh-TUI repository](https://github.com/ccch1mneyyy/dsh-TUI) as the
+`dsh-auth/` submodule and mirrors to this repository.
+
+## Roadmap
+
+- **M2** *(landed)* — dsh-tui integration: `/provider` OAuth branch, `/login`
+  account section, two-level `/model` picker with a pinned recently-used
+  group.
+- **M3** — `dsh-ecosystem-spec` conformance (manifest validation, admission
+  fixtures) plus the remaining pi-ai OAuth providers (GitHub Copilot,
+  OpenRouter, Kimi); community list entry.
+- **M4** — Gemini: a custom Google device-code flow (pi-ai ships none; this
+  is the one wheel this project plans to build itself).
+
+## License
+
+MIT

package/node_modules/@deepseek-harness-tui/dsh-auth/cordis.patch.yml

@@ -0,0 +1,11 @@
+# @deepseek-harness-tui/dsh-auth bundle patch: mounts the subscription OAuth
+# provider routes and the /auth command as a profile layer
+# (`dsh plugin --profile <name> add @deepseek-harness-tui/dsh-auth`).
+#
+# Entry-level inject — never a code-level one (see the plugin module's
+# `inject` export): a stale patch must not deadlock a composition whose
+# llm/commands services arrive later or are absent entirely.
+- insert:
+    - id: dsh-auth
+      name: '@deepseek-harness-tui/dsh-auth'
+      inject: [llm, commands]

package/node_modules/@deepseek-harness-tui/dsh-auth/dsh-plugin.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "https://dsh.community/schemas/dsh-plugin-0.15.json",
+  "id": "com.dsh-tui.dsh-auth",
+  "name": "dsh-auth",
+  "version": "0.1.0",
+  "manifestVersion": "0.15",
+  "description": "Subscription OAuth sign-in (ChatGPT/Codex, Claude Pro/Max, SuperGrok) as LLM provider routes for DeepSeek Harness. Registers llm adapter routes through the cordis llm registry; interactive login runs over the user-questions seam and degrades to a clear refusal when no interactive surface is present.",
+  "facets": {
+    "host": {
+      "entry": "lib/index.js",
+      "apiVersion": "v1alpha1"
+    }
+  },
+  "requires": {
+    "contracts": [
+      {
+        "apiVersion": "commands.dsh/v1alpha1",
+        "kind": "Command"
+      },
+      {
+        "apiVersion": "user-questions.dsh/v1alpha1",
+        "kind": "UserQuestions",
+        "optional": true,
+        "fallback": "login refuses with guidance instead of assuming a browser or GUI is present (TUI-RUN-001)"
+      }
+    ]
+  },
+  "contributes": {
+    "commands": [
+      {
+        "id": "dsh.auth",
+        "title": "Sign in with a provider subscription (OAuth)"
+      }
+    ]
+  },
+  "permissions": [
+    {
+      "name": "commands.invoke",
+      "scope": "dsh.auth",
+      "reason": "run /auth status|login|logout from any composed command surface"
+    }
+  ],
+  "license": "MIT"
+}

package/node_modules/@deepseek-harness-tui/dsh-auth/lib/command.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The `/auth` command: a textual veneer over the {@link DshAuthApi} — status
+ * listing, login (optionally picking the provider interactively), logout.
+ *
+ * @module dsh-auth/command
+ */
+import type { CommandInvocation, CommandResult } from '@deepseek-ai/dsh-commands';
+import type { DshAuthApi } from './service.js';
+/**
+ * Build the `/auth` handler. Every failure returns a `CommandResult`, never a
+ * rejection the host would have to translate; unexpected throws still
+ * propagate for the host's own error surface.
+ */
+export declare function createAuthCommandHandler(api: DshAuthApi): (invocation: CommandInvocation) => Promise<CommandResult>;