@aryacode/dsh-aryacode-polish 0.6.2 → 0.8.1

package/client/switches.json

@@ -30,6 +30,12 @@
       "label": "Add a workspace from this PC or GitHub",
       "description": "Put an On this PC / GitHub repository source menu behind the Workspaces + button.",
       "defaultOn": true
+    },
+    {
+      "key": "panelScreenshot",
+      "label": "Right-panel screenshot",
+      "description": "Copy the open right panel into the chat as an image, and onto the clipboard.",
+      "defaultOn": true
     }
   ]
 }

package/docs/github-workspaces.md

@@ -31,6 +31,30 @@ server rejects a bearer token for clone, which is why the header carries
 `x-access-token` basic auth. Every line of git output is scrubbed of the token
 before it can reach the browser, and the route answers `cache-control: no-store`.
 
+## Signing in and out
+
+The session belongs to the GitHub CLI, and both directions stay inside the app:
+
+- **Sign in** runs `gh auth login --hostname github.com --git-protocol https
+  --web --clipboard --skip-ssh-key` on the Host. With piped stdio that command
+  needs no terminal: it prints `! One-time code (XXXX-XXXX) copied to clipboard`
+  and `https://github.com/login/device`, then polls GitHub until the code is
+  approved. The dialog shows exactly that code with a copy button and the device
+  page, polls `loginStatus` every two seconds, and refreshes the repository list
+  the moment the CLI reports success. A flow that is never approved is killed
+  after five minutes, and cancelling it kills the child immediately; the child
+  also dies with the feature, because a pending sign-in is a live process.
+- **Sign out** runs `gh auth logout --hostname github.com --user <login>` after a
+  second confirming click, then re-reads the session. "not logged in" counts as
+  success, because that is the state the click asked for.
+- **Where you see it** is the sidebar foot: `GitHub · <login>` or
+  `GitHub · signed out`, on the same line as the balance. The dialog repeats it,
+  and the footer row re-reads on window focus so a `gh auth login` run in a
+  terminal shows up without a restart.
+
+Nothing about this stores a credential of its own: the code is a one-time device
+code, and the token never leaves the CLI's own credential store.
+
 ## How the entry point works
 
 The "+" menu's **Add workspace…** entry only appears when something occupies

package/docs/panel-screenshot.md

@@ -0,0 +1,98 @@
+# Right-panel screenshot
+
+The right panel grows a camera button in its own top-right corner, beside the
+Shell's split, expand and close controls. One click photographs the right
+panel's **open tab**, puts the picture on the clipboard, and attaches it to the
+message being written — the same place a pasted screenshot lands, so it can be
+sent with the next prompt without touching another tool.
+
+This page records how that works, and — more importantly — what it cannot do,
+because the honest limits are the part that decides whether it replaces a snip
+tool for a given job.
+
+## What it captures
+
+The right panel is ordinary DOM in the same document as the chat, so the target
+is found with an attribute selector rather than a private class name:
+
+| target | selector |
+|---|---|
+| the open tab's body | `[data-sidebar-right-session][data-sidebar-right-open] [data-dockkit-pane-active]` |
+| the panel itself (fallback) | `[data-sidebar-right-session][data-sidebar-right-open]` |
+| the bottom panel (fallback) | `[data-dsh-panel][data-dsh-bottom-panel]` |
+
+The first selector is what makes this work for both right sides: the Shell's own
+sidebar and `dsh-better-sidebar` both render their tabs through the same dock
+container, so the *active pane* is the current tab in either one. Targets are
+skipped when they are smaller than 48 px in either direction, which keeps a
+collapsed panel from producing a sliver.
+
+## How the picture is made
+
+`html2canvas` (vendored at `vendor/html2canvas.min.js`, inlined into
+`lib/client.js` by `scripts/build-client.mjs`) rasterises the element in the page
+at `min(2, max(1.5, devicePixelRatio))`. The background is the first opaque
+ancestor colour, so a transparent panel still reads as a surface.
+
+This is the only route a plugin has. The Shell exposes:
+
+- **no capture bridge** — the desktop preload exposes `__DSH_DIRECTORY_PICKER__`,
+  `__DSH_HOST_PATHS__`, `dshDesktopBoot`, `dshDesktop`, `dshPlatform`, and no
+  screenshot channel;
+- **no working `getDisplayMedia`** — the API exists, but nothing installs a
+  display-media request handler on the app's session, so the call is refused
+  outright rather than offering a source;
+- **no Host route to pixels** — the Host runs in a separate process and has no
+  access to the renderer.
+
+Capture therefore happens in the renderer, from the DOM, which is also why it
+works identically in the web build and in the app.
+
+## What it cannot capture
+
+1. **The browser tab and the HTML preview.** Both render inside an
+   `<iframe>`/`<webview>` whose document is not readable from the page, so a
+   rasteriser sees an empty rectangle there. Everything else — files, documents,
+   images, diffs, plans, subagent chats, plugin tabs — is plain DOM and captures
+   normally.
+2. **Anything outside the app window.** The button photographs a panel, not the
+   desktop, so a snip tool still wins for a region spanning two applications or a
+   native dialog.
+3. **Live pixels that refuse to be copied.** A cross-origin image without CORS
+   headers taints the canvas and would throw; the capture fails with a notice
+   instead of producing a blank picture. The Shell's own panels are same-origin,
+   so this only shows up with third-party content.
+
+## How the image reaches the message
+
+Two calls, in this order, mirroring the composer's own intake:
+
+```js
+// mints the draft attachment and starts its upload
+const drafts = ctx.get('conversation').createDrafts(sessionId, [file], true)
+// puts the minted ids in the composer, where the user can see and remove them
+props.inputActions.addAttachments(drafts.map((draft) => draft.id))
+```
+
+`createDrafts` is not part of the public `IConversation` interface, but it is the
+only `File` → id entry point in the Shell, and the product itself reaches it the
+same way. `addAttachments` is the public half: it is a standard prop on
+session-scoped slots, which the composer row already is. The button itself is
+root-level (it sits over the panel, not inside its DOM), so the composer dock
+keeps an invisible entry that publishes the session context into a store; the
+button reads that store and disappears when no Session is open. The bytes travel over
+the Shell's own upload route, so a screenshot behaves exactly like a pasted
+image, including for the model that receives it.
+
+## When it refuses
+
+The button reports its own state instead of failing silently:
+
+- no panel open → *open a panel on the right first*
+- clipboard blocked → the image is still attached, with *right panel attached,
+  clipboard refused*
+- anything else → the reason in the row, plus
+  `[aryacode-polish] panel screenshot failed:` in the console
+
+The switch is in the row's Configure page like every other surface, and turning
+it off removes the button without unloading anything else.

package/entries/github.js

@@ -114,6 +114,189 @@ export async function ghToken(run = runCommand) {
   return token === '' ? undefined : token
 }
 
+/**
+ * Pull the one-time code out of what `gh auth login --web` prints.
+ *
+ * The CLI writes `! One-time code (AE22-76C7) copied to clipboard` to stderr —
+ * the dash is the one the browser form accepts, so it is kept verbatim.
+ * @param text - captured output.
+ * @returns the code, or undefined when the line has not arrived yet.
+ */
+export function parseDeviceCode(text) {
+  const match = /one-time code \(([A-Z0-9]{4}-[A-Z0-9]{4})\)/i.exec(String(text))
+  return match === null ? undefined : match[1].toUpperCase()
+}
+
+/**
+ * Pull the verification URL out of what `gh auth login --web` prints.
+ * @param text - captured output.
+ * @returns the URL, defaulting to GitHub's device page.
+ */
+export function parseDeviceUrl(text) {
+  const match = /(https:\/\/github\.com\/login\/device)/.exec(String(text))
+  return match === null ? 'https://github.com/login/device' : match[1]
+}
+
+/** The single sign-in this process is running, if any. */
+let loginSession
+
+/** Default ceiling on a pending sign-in: the CLI polls until the code is used. */
+export const LOGIN_TIMEOUT_MS = 5 * 60 * 1000
+
+/**
+ * Start the GitHub CLI's device flow for this machine.
+ *
+ * `gh auth login --web` needs no terminal: with piped stdio it prints the
+ * one-time code and then polls GitHub until the code is approved, which is
+ * exactly the shape a dialog can render. The child is kept alive here so the
+ * browser can poll for the outcome, and killed when the flow is cancelled,
+ * times out, or the feature is disposed.
+ * @param options - spawn override plus the timeout.
+ * @returns the code and URL to show, or the reason it could not start.
+ */
+export function startLogin(options = {}) {
+  if (loginSession !== undefined && loginSession.state === 'pending') {
+    return { ok: true, value: { state: 'pending', code: loginSession.code, url: loginSession.url } }
+  }
+  const spawnImpl = options.spawn ?? spawn
+  const timeoutMs = options.timeoutMs ?? LOGIN_TIMEOUT_MS
+  const session = { state: 'starting', code: undefined, url: 'https://github.com/login/device', reason: '', child: undefined, timer: undefined }
+  let text = ''
+  const read = chunk => {
+    text += chunk.toString()
+    const code = parseDeviceCode(text)
+    if (code !== undefined && session.code === undefined) {
+      session.code = code
+      session.url = parseDeviceUrl(text)
+      session.state = 'pending'
+    }
+  }
+  try {
+    const child = spawnImpl('gh', ['auth', 'login', '--hostname', 'github.com', '--git-protocol', 'https', '--web', '--clipboard', '--skip-ssh-key'], {
+      stdio: ['pipe', 'pipe', 'pipe'],
+      windowsHide: true,
+      env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GH_PROMPT_DISABLED: '' },
+    })
+    session.child = child
+    child.stdout?.setEncoding?.('utf8')
+    child.stderr?.setEncoding?.('utf8')
+    child.stdout?.on?.('data', read)
+    child.stderr?.on?.('data', read)
+    child.on?.('error', error => {
+      session.state = 'failed'
+      session.reason = error instanceof Error ? error.message : 'the GitHub CLI could not be started'
+    })
+    child.on?.('close', code => {
+      if (session.state === 'cancelled') return
+      if (code === 0) {
+        session.state = 'succeeded'
+        session.reason = ''
+        return
+      }
+      session.state = 'failed'
+      const parsed = parseDeviceCode(text)
+      session.reason = parsed === undefined
+        ? 'the GitHub CLI stopped before showing a one-time code'
+        : 'the one-time code was not approved'
+    })
+    session.timer = setTimeout(() => {
+      if (session.state !== 'pending' && session.state !== 'starting') return
+      session.state = 'failed'
+      session.reason = 'the one-time code expired before it was approved'
+      session.child?.kill?.()
+    }, timeoutMs)
+    session.timer?.unref?.()
+    loginSession = session
+    return { ok: true, value: { state: session.state, code: session.code, url: session.url } }
+  } catch (error) {
+    session.state = 'failed'
+    session.reason = error instanceof Error ? error.message : 'the GitHub CLI could not be started'
+    loginSession = session
+    return { ok: false, error: session.reason }
+  }
+}
+
+/**
+ * Report the sign-in this process is running.
+ * @returns the state, plus the code and URL while it is pending.
+ */
+export function loginStatus() {
+  if (loginSession === undefined) return { state: 'idle', code: undefined, url: 'https://github.com/login/device', reason: '' }
+  return { state: loginSession.state, code: loginSession.code, url: loginSession.url, reason: loginSession.reason }
+}
+
+/**
+ * Stop a pending sign-in and forget it.
+ * @returns the state after cancelling.
+ */
+export function cancelLogin() {
+  if (loginSession === undefined) return { state: 'idle', code: undefined, url: 'https://github.com/login/device', reason: '' }
+  if (loginSession.timer !== undefined) clearTimeout(loginSession.timer)
+  try {
+    loginSession.child?.kill?.()
+  } catch {
+    // A child that already exited is the normal case here.
+  }
+  loginSession.state = 'cancelled'
+  loginSession.reason = 'sign-in was cancelled'
+  return { state: loginSession.state, code: loginSession.code, url: loginSession.url, reason: loginSession.reason }
+}
+
+/**
+ * Sign the GitHub CLI out, which is what this feature's sign-in state reads.
+ * @param login - the account to remove; the CLI prompts without it.
+ * @param run - command runner, injected by tests.
+ * @returns ok when the account is gone (including when it was never there).
+ */
+export async function signOut(login, run = runCommand) {
+  const args = ['auth', 'logout', '--hostname', 'github.com']
+  if (typeof login === 'string' && login !== '') args.push('--user', login)
+  const answer = await run('gh', args)
+  if (answer.code === 0) return { ok: true }
+  const text = `${answer.stdout}${answer.stderr}`.trim()
+  if (/not logged in/i.test(text)) return { ok: true }
+  return { ok: false, error: text === '' ? 'the GitHub CLI could not sign out' : text }
+}
+
+/**
+ * Read every account the GitHub CLI holds for github.com.
+ *
+ * A machine can carry more than one account in the CLI keyring, and `gh auth
+ * logout --user` only removes the one it names — the CLI then makes another one
+ * active, which is why a sign-out can appear to do nothing.
+ *
+ * @param run - command runner, injected by tests.
+ * @returns the accounts in the CLI's own order, the active one first when known.
+ */
+export async function listAccounts(run = runCommand) {
+  const answer = await run('gh', ['auth', 'status'])
+  const text = `${answer.stdout}${answer.stderr}`
+  const logins = []
+  const pattern = /Logged in to github\.com account ([^\s]+)/g
+  let match = pattern.exec(text)
+  while (match !== null) {
+    if (logins.indexOf(match[1]) === -1) logins.push(match[1])
+    match = pattern.exec(text)
+  }
+  return logins
+}
+
+/**
+ * Sign every account out of the GitHub CLI.
+ * @param logins - accounts to remove.
+ * @param run - command runner, injected by tests.
+ * @returns ok when no account is left, else the first failure.
+ */
+export async function signOutAll(logins, run = runCommand) {
+  const removed = []
+  for (const login of logins) {
+    const answer = await signOut(login, run)
+    if (answer.ok !== true) return { ok: false, error: answer.error, removed }
+    removed.push(login)
+  }
+  return { ok: true, removed }
+}
+
 /**
  * Read the login that owns a token.
  * @param token - GitHub access token.
@@ -257,19 +440,49 @@ export async function cloneRepo(owner, name, token, options = {}) {
  */
 export async function handleRequest(body, deps = {}) {
   const action = body?.action
+  // Sign-in is reachable while signed out: it is how a machine gets there.
+  if (action === 'login') return (deps.startLogin ?? startLogin)()
+  if (action === 'loginStatus') return { ok: true, value: (deps.loginStatus ?? loginStatus)() }
+  if (action === 'loginCancel') return { ok: true, value: (deps.cancelLogin ?? cancelLogin)() }
+  // Signing everything out is reachable while signed in, so it belongs above the
+  // token gate together with the sign-in verbs.
+  if (action === 'logoutAll') {
+    const accounts = await (deps.accounts ?? listAccounts)()
+    if (accounts.length === 0) return { ok: true, value: { logins: [] } }
+    const answer = await (deps.signOutAll ?? signOutAll)(accounts)
+    if (answer.ok !== true) return { ok: false, error: answer.error }
+    return { ok: true, value: { logins: answer.removed } }
+  }
   const token = await (deps.token ?? ghToken)()
   if (action === 'status') {
+    const accounts = await (deps.accounts ?? listAccounts)().catch(() => [])
     if (token === undefined) {
       return {
         ok: true,
-        value: { signedIn: false, login: '', root: cloneRoot(deps.home), reason: 'The GitHub CLI is missing or not signed in: run `gh auth login` in a terminal.' },
+        value: {
+          signedIn: false,
+          login: '',
+          accounts: [],
+          root: cloneRoot(deps.home),
+          reason: 'The GitHub CLI is not signed in on this machine. Sign in from this dialog, or run `gh auth login` in a terminal.',
+        },
       }
     }
     const login = await (deps.login ?? fetchLogin)(token)
-    return { ok: true, value: { signedIn: true, login, root: cloneRoot(deps.home), reason: '' } }
+    return { ok: true, value: { signedIn: true, login, accounts, root: cloneRoot(deps.home), reason: '' } }
   }
   if (token === undefined) {
-    return { ok: false, error: 'Sign in with the GitHub CLI first: run `gh auth login` in a terminal, then try again.' }
+    return { ok: false, error: 'Sign in to GitHub first: use Sign in here, or run `gh auth login` in a terminal.' }
+  }
+  if (action === 'logout') {
+    const login = await (deps.login ?? fetchLogin)(token)
+    const answer = await (deps.signOut ?? signOut)(login)
+    if (answer.ok !== true) return { ok: false, error: answer.error }
+    // The CLI may fall back to another account in its keyring; report which one,
+    // so the dialog can say what is signed in now instead of going silent.
+    const after = await (deps.token ?? ghToken)().catch(() => undefined)
+    const remaining = after === undefined ? '' : await (deps.login ?? fetchLogin)(after).catch(() => '')
+    return { ok: true, value: { login, remaining } }
   }
   if (action === 'repos') {
     const repos = await (deps.repos ?? fetchRepos)(token)
@@ -307,6 +520,8 @@ export const githubFeature = {
   name: 'polish-github',
   inject: ['connection'],
   apply(ctx, config = {}) {
+    // A pending device flow holds a child process: it must die with the feature.
+    ctx.effect(() => () => { cancelLogin() })
     ctx.effect(() => ctx.connection.fetch.register({
       path: GITHUB_ROUTE,
       // Without a method list the platform would only route GET, which is why the

package/entries/registry.js

@@ -68,6 +68,12 @@ export const features = [
     defaultOn: true,
     mount: mountFolders,
   },
+  {
+    id: 'panelScreenshot',
+    label: 'Right-panel screenshot',
+    description: 'Copy the open right panel into the chat as an image, and onto the clipboard.',
+    defaultOn: true,
+  },
 ]
 
 /**