dsh-ops 0.2.3 → 0.2.5-beta.1

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "dsh-ops",
-  "version": "0.2.3",
+  "version": "0.2.5-beta.1",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "tag": "beta"
   },
   "repository": {
     "type": "git",
@@ -39,7 +40,22 @@
       "default": "./lib/policy.js"
     },
     "./package.json": "./package.json",
-    "./locale/*.json": "./locale/*.json"
+    "./locale/*.json": "./locale/*.json",
+    "./shell": {
+      "default": "./lib/components/shell/index.js"
+    },
+    "./shell/package.json": "./lib/components/shell/package.json",
+    "./shell/locale/*.json": "./lib/components/shell/locale/*.json",
+    "./file": {
+      "default": "./lib/components/file/index.js"
+    },
+    "./file/package.json": "./lib/components/file/package.json",
+    "./file/locale/*.json": "./lib/components/file/locale/*.json",
+    "./background": {
+      "default": "./lib/components/background/index.js"
+    },
+    "./background/package.json": "./lib/components/background/package.json",
+    "./background/locale/*.json": "./lib/components/background/locale/*.json"
   },
   "bin": {
     "dsh-ops": "bin/dsh-ops.mjs"
@@ -51,6 +67,7 @@
   },
   "files": [
     "lib",
+    "packages/auto-compact",
     "bin",
     "cordis.patch.yml",
     "dsh-plugin.json",
@@ -97,8 +114,8 @@
     }
   },
   "optionalDependencies": {
-    "@dsh-ops/fastctx-win32-x64": "0.2.1",
     "@dsh-ops/bash-win32-x64": "0.2.1",
+    "@dsh-ops/fastctx-win32-x64": "0.2.1",
     "@dsh-ops/pwsh-win32-x64": "0.2.1"
   },
   "devDependencies": {
@@ -112,5 +129,11 @@
   },
   "engines": {
     "node": "^22.19 || >=24"
+  },
+  "bundleDependencies": [
+    "@dsh-ops/auto-compact"
+  ],
+  "dependencies": {
+    "@dsh-ops/auto-compact": "file:packages/auto-compact"
   }
 }

package/packages/README.md

@@ -0,0 +1,87 @@
+# Platform package skeletons
+
+The three directories here are the **skeletons** of the platform packages this
+plugin publishes, one per package, named `<kind>-<platform>-<arch>`. They are
+not the same kind of package:
+
+| Skeleton | Published as | What it carries |
+| --- | --- | --- |
+| `fastctx-win32-x64/` | the FastCtx package for Windows x64 | a payload: `bin/fastctx.exe`, built from `vendor/fastctx`, plus the Apache-2.0 licence and notice documents |
+| `bash-win32-x64/` | the bash pin package for Windows x64 | metadata only: a pin on Git for Windows PortableGit |
+| `pwsh-win32-x64/` | the pwsh pin package for Windows x64 | metadata only: a pin on PowerShell 7 |
+
+Each skeleton holds only what is committed by hand: the package metadata, this
+documentation, and — for the FastCtx package — the licence and notice documents
+that must travel with the binary. **No binary is ever committed here.**
+
+## What the build puts in each package
+
+`scripts/build-platform-packages.mjs` writes every package to
+`<dist>/stage/<kind>-<platform>-<arch>/`.
+
+The **payload** package:
+
+```text
+fastctx-win32-x64/
+├── package.json                    name and version injected, the rest from the skeleton
+├── provenance.json                 source, toolchain, upstream revision, payload digest
+├── bin/fastctx.exe                 the payload
+├── LICENSE, NOTICE, FORK.md,       carried verbatim from vendor/fastctx, as Apache-2.0
+├── UPSTREAM.md,                    requires of a redistributor
+│   THIRD_PARTY_LICENSES*.md
+└── README.md
+```
+
+The **pin** packages:
+
+```text
+bash-win32-x64/  (and pwsh-win32-x64/)
+├── package.json                    name and version injected, the rest from the skeleton
+├── provenance.json                 the pin: repository, tag, asset name, URL, sha256,
+│                                   bytes, the measured unpacked size (files and bytes),
+│                                   unpacked layout, entry point and its digest, licence,
+│                                   copyright, and the statement that this package
+│                                   forwards no upstream bytes
+└── README.md
+```
+
+Two rules keep a pin a pin, and both are enforced rather than asserted:
+
+- **The stage may contain nothing else.** After assembly the script lists every
+  file in a pin package's stage and fails if any file is not one of
+  `package.json`, `provenance.json`, `README.md`. `--check` re-runs the same
+  test on the existing stages, so an upstream byte cannot slip into a pin
+  without failing a gate.
+- **The pin is data, not a copy of the digests in prose.** `provenance.json` is
+  generated from the pin record — today read from `lib/shells.js` when that
+  module exports a pin table or pin function, and otherwise from the measured
+  fallback inside the build script, which the script announces on every run and
+  `--check` prints. `--verify-upstream` re-derives each asset digest from the
+  live upstream release and deletes the download again, so a stale pin is one
+  command away from being caught.
+
+## Where the names come from
+
+**The package name lives in exactly one module.** `lib/shells.js`
+(`PLATFORM_PACKAGES`) owns the shell names and therefore the scope; the FastCtx
+name comes from `lib/binary.js` (`opsFastctxPackage`). The build script imports
+them and never spells a name out, which is why the skeleton `package.json` files
+carry neither `name` nor `version` — a re-scoped release is one edit in `lib/`,
+not a search-and-replace here.
+
+The version of a platform package is always the version of the main package
+(`package.json`), injected at build time so the two can never disagree.
+
+## Only the payload package is injected
+
+The main package's published copy declares the FastCtx platform package as an
+`optionalDependency` — injected by the build script, never in the committed
+manifest, where a version nobody has published yet would make every
+contributor's `npm install` a 404.
+
+The two shell pins are published but **never injected**, because installing one
+alone cannot work: a pin carries no shell, so a dependency on it would install
+metadata where a deployment expects a binary. They exist for a deployment that
+deliberately resolves a shell — the plugin's own provisioning path, or an
+explicit install — and an install on a platform they do not cover skips them
+instead of failing.

package/packages/auto-compact/LICENSE

@@ -0,0 +1,30 @@
+MIT License
+
+Copyright (c) 2026 T-Auto and the dsh-ops contributors
+
+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.
+
+-------------------------------------------------------------------------------
+
+This MIT license covers the dsh-ops plugin: everything in this repository
+except `vendor/fastctx/`, which is FastCtx under the Apache License 2.0. The
+distribution as a whole is therefore licensed under the composite
+`MIT AND Apache-2.0`. See `NOTICE` for the full statement and the attribution
+FastCtx requires, and `vendor/fastctx/LICENSE-APACHE` for the Apache License
+2.0 text.

package/packages/auto-compact/README.md

@@ -0,0 +1,23 @@
+# @dsh-ops/auto-compact
+
+Internal, bundled companion of dsh-ops. It adds one independently toggled row to
+**Plugins → dsh-ops → Included components**, not a second marketplace bundle.
+The package-root entry is required by DSH rc.2's browser module discovery; plugin
+subpaths are not browser entry points. No separate installation is required.
+
+Defaults: threshold 50% (integer 1–99), cooldown 120s (30–3600), timeout 120s
+(10–600). Configuration belongs to this row and uses host profile settings with
+revision fencing and restore defaults. The policy calls the same public idle
+maintenance API as `/compact` only above the rounded Web context percentage and
+after a non-cancelled turn. Running tools are not interrupted. No new model-facing
+tool, polling, or host auto-policy modification is introduced.
+
+One owned operation at a time, cooldown, unchanged-surface suppression and
+abort/drain teardown bound work. Commit/save failures suspend this session until
+component reload and require inspection. Timeouts rely on cooperative cancellation.
+Summarization may call the host's configured model and incur cost; it is not
+lossless. Missing samples/capacity and busy admission skip work.
+
+This companion is carried by the dsh-ops 0.2.5-beta.1 prerelease candidate, not the
+stable 0.2.4. Check registry metadata for publication status. See the main repository's
+`docs/auto-compact.md` for safety limits and manual acceptance requirements.

package/packages/auto-compact/lib/client.js

@@ -0,0 +1,79 @@
+/** Browser artifact in the host's closure-factory module format; no globals except its loader. */
+window.__ModuleLoader__.load({ id: '@dsh-ops/auto-compact', factory: require => {
+  const { createElement: h, useState, useEffect, useRef } = require('react')
+  const NS = 'dshOps.autoCompact'
+  const dictionaries = {
+    en: {
+      title: 'Settings', threshold: 'Context threshold (%)', cooldown: 'Cooldown (seconds)', timeout: 'Compaction timeout (seconds)',
+      save: 'Save', reset: 'Restore defaults', saved: 'Saved', failed: 'Not saved. Configuration may have changed; reload and retry.',
+      unavailable: 'Enable this component to configure it. This client must have host settings write access.',
+      hint: 'When the Web context meter is strictly above the threshold, compact at the next idle boundary using the same service as /compact. Running tools are not interrupted. Summarization may call your configured model and incur cost. No extra model-facing tool is added.',
+      invalid: 'Enter integers: threshold 1–99, cooldown 30–3600, timeout 10–600.',
+    },
+    zh: {
+      title: '设置', threshold: '上下文阈值（%）', cooldown: '冷却时间（秒）', timeout: '压缩超时（秒）',
+      save: '保存', reset: '恢复默认', saved: '已保存', failed: '未保存，配置可能已变化，请重新加载后重试。',
+      unavailable: '请先启用此组件；当前客户端还需具有宿主设置写入权限。',
+      hint: 'Web 上下文占用严格高于阈值后，在下一次空闲边界调用与 /compact 相同的服务；不会打断正在运行的工具。摘要可能调用已配置模型并产生费用，不额外增加模型可调用工具。',
+      invalid: '请输入整数：阈值 1–99，冷却 30–3600 秒，超时 10–600 秒。',
+    },
+  }
+  const defaults = { thresholdPercent: 50, cooldownSeconds: 120, timeoutSeconds: 120 }
+  const fields = [
+    ['thresholdPercent', 'threshold', 1, 99],
+    ['cooldownSeconds', 'cooldown', 30, 3600],
+    ['timeoutSeconds', 'timeout', 10, 600],
+  ]
+  function Settings({ view, form, t }) {
+    const [draft, setDraft] = useState(defaults)
+    const [revision, setRevision] = useState(undefined)
+    const [busy, setBusy] = useState(false)
+    const [message, setMessage] = useState('')
+    const alive = useRef(false)
+    useEffect(() => { alive.current = true; return () => { alive.current = false } }, [])
+    useEffect(() => {
+      if (form?.state.status === 'ready') {
+        setDraft({ ...defaults, ...form.state.value })
+        setRevision(form.state.revision)
+      }
+    }, [form?.state.revision, form?.state.status])
+    if (view === 'summary') return t('hint')
+    const writable = form?.state.status === 'ready' && form.state.writable && form.state.mode === 'host'
+    async function save(reset) {
+      if (!writable || busy || revision === undefined) return
+      if (!reset && fields.some(([key, , min, max]) => !Number.isInteger(Number(draft[key])) || String(draft[key]).trim() === '' || Number(draft[key]) < min || Number(draft[key]) > max)) {
+        setMessage(t('invalid')); return
+      }
+      setBusy(true); setMessage('')
+      try {
+        const ops = fields.map(([key]) => reset
+          ? { op: 'unset', path: [key] }
+          : { op: 'set', path: [key], value: Number(draft[key]) })
+        const ok = await form.mutate(ops, revision)
+        if (alive.current) setMessage(t(ok ? 'saved' : 'failed'))
+      } catch { if (alive.current) setMessage(t('failed')) }
+      finally { if (alive.current) setBusy(false) }
+    }
+    return h('section', { 'data-dsh-ops-auto-compact-settings': true },
+      h('h4', null, t('title')),
+      h('p', null, t('hint')),
+      !writable ? h('p', { role: 'status' }, t('unavailable')) : null,
+      ...fields.map(([key, label, min, max]) => h('label', { key, style: { display: 'block', marginBottom: 12 } },
+        t(label), ' ', h('input', {
+          type: 'number', min, max, step: 1, value: draft[key], disabled: !writable || busy,
+          onChange: event => setDraft(current => ({ ...current, [key]: event.target.value })),
+        }))),
+      h('button', { type: 'button', disabled: !writable || busy, onClick: () => save(false) }, t('save')), ' ',
+      h('button', { type: 'button', disabled: !writable || busy, onClick: () => save(true) }, t('reset')),
+      h('p', { role: 'status' }, message))
+  }
+  return {
+    inject: ['slots', 'locale'],
+    apply(ctx) {
+      ctx.effect(() => ctx.get('locale').register(NS, dictionaries), 'dsh-ops settings locales')
+      ctx.get('slots').inject('plugins.row.config', () => ctx.get('slots').register({
+        name: 'plugins.row.config', key: 'dsh-ops#dsh-ops-auto-compact', locale: NS,
+      }, Settings))
+    },
+  }
+} })

package/packages/auto-compact/lib/config.js

@@ -0,0 +1,60 @@
+/** Dependency-free strict settings and structural host form descriptor. */
+export const AUTO_COMPACT_DEFAULTS = Object.freeze({ thresholdPercent: 50, cooldownSeconds: 120, timeoutSeconds: 120 })
+const LIMITS = Object.freeze({ thresholdPercent: [1, 99], cooldownSeconds: [30, 3600], timeoutSeconds: [10, 600] })
+const WRITE = Symbol.for('cosmokit.volatile.write')
+
+export function resolveAutoCompactConfig(input = {}) {
+  if (input === null || typeof input !== 'object' || Array.isArray(input)
+    || ![Object.prototype, null].includes(Object.getPrototypeOf(input))) {
+    throw new TypeError('dsh-ops auto-compact config must be a plain object')
+  }
+  for (const key of Object.keys(input)) {
+    if (!Object.hasOwn(LIMITS, key)) throw new TypeError(`dsh-ops auto-compact: unknown config key ${key}`)
+  }
+  return Object.fromEntries(Object.entries(AUTO_COMPACT_DEFAULTS).map(([key, fallback]) => {
+    const raw = input[key]
+    const value = raw !== null && typeof raw === 'object' && WRITE in raw ? raw.get() : raw === undefined ? fallback : raw
+    const [min, max] = LIMITS[key]
+    if (!Number.isInteger(value) || value < min || value > max) {
+      throw new TypeError(`dsh-ops auto-compact: ${key} must be an integer between ${min} and ${max}`)
+    }
+    return [key, value]
+  }))
+}
+
+/**
+ * Standard Schema validation plus a serializable structural descriptor, not a
+ * Schemastery instance or vendor impersonation. The host rehydrates with its OWN
+ * library. No loading-time host values are imported. Live references implement
+ * the shared cosmokit.volatile.write protocol and are validated before updates.
+ */
+export function createAutoCompactConfigSchema() {
+  const dict = Object.fromEntries(Object.entries(AUTO_COMPACT_DEFAULTS).map(([key, value]) => [key, {
+    type: 'number',
+    meta: { default: value, min: LIMITS[key][0], max: LIMITS[key][1], step: 1, volatile: true },
+    toJSON() { return { type: this.type, meta: { ...this.meta } } },
+  }]))
+  return {
+    type: 'object', meta: { default: {} }, dict,
+    '~standard': {
+      version: 1, vendor: 'dsh-ops',
+      validate(input) {
+        try {
+          const value = Object.fromEntries(Object.entries(resolveAutoCompactConfig(input)).map(([key, initial]) => {
+            let current = initial
+            return [key, Object.freeze({ get: () => current, [WRITE]: next => { current = next } })]
+          }))
+          return { value }
+        } catch (error) { return { issues: [{ message: error.message }] } }
+      },
+    },
+    toJSON() {
+      const refs = { 0: { type: 'object', meta: { default: {} }, dict: {} } }
+      Object.entries(dict).forEach(([key, node], index) => {
+        refs[0].dict[key] = index + 1
+        refs[index + 1] = { type: node.type, meta: { ...node.meta } }
+      })
+      return { uid: 0, refs }
+    },
+  }
+}

package/packages/auto-compact/lib/index.js

@@ -0,0 +1,132 @@
+/** Idle-only policy over the same public compaction seam as /compact. */
+import { createAutoCompactConfigSchema, resolveAutoCompactConfig } from './config.js'
+
+export const name = 'dsh-ops-auto-compact'
+export const inject = ['compaction', 'sessionProjections']
+export const Config = createAutoCompactConfigSchema()
+
+/** Match the Web context meter; absent/invalid samples never trigger work. */
+export function contextPercent(pressure) {
+  const used = pressure?.projectedTokens ?? pressure?.pressureTokens
+  const capacity = pressure?.contextWindow
+  if (!Number.isFinite(used) || used < 0 || !Number.isFinite(capacity) || capacity <= 0) return null
+  return Math.min(100, Math.round(used / capacity * 100))
+}
+
+/** Surface changes, not compaction bookkeeping, permit a fresh attempt. */
+function surfaceKey(session) {
+  return JSON.stringify([session.surface.contentGeneration, session.surface.nodes])
+}
+
+/** Bounded, event-driven supervisor. It never publishes a model-callable tool. */
+export function createAutoCompactor(ctx, rawConfig, {
+  now = Date.now, setTimer = setTimeout, clearTimer = clearTimeout,
+} = {}) {
+  const states = new WeakMap()
+  const active = new Map()
+  const disposedAgents = new WeakSet()
+  let closed = false
+  // One summary at a time for this component, across all sessions.
+  let globalNextAt = 0
+
+  function check(agent) {
+    if (closed || disposedAgents.has(agent) || agent.status !== 'idle' || active.size > 0) return
+    let config, percent, key
+    try {
+      config = resolveAutoCompactConfig(rawConfig)
+      percent = contextPercent(ctx.get('sessionProjections').snapshot(agent.session, ['contextPressure']).values.contextPressure)
+      key = surfaceKey(agent.session)
+    } catch {
+      // No guessed capacity, no admission when a required service disappears.
+      return
+    }
+    if (percent === null || percent <= config.thresholdPercent) return
+    const state = states.get(agent.session)
+    const time = now()
+    if (time < globalNextAt || time < (state?.nextAt ?? 0)
+      || state?.blocked
+      || state?.key === key && state.threshold === config.thresholdPercent) return
+
+    const controller = new AbortController()
+    const slot = { controller, done: undefined }
+    // Install before calling compactNow: service admission may emit synchronously.
+    active.set(agent, slot)
+    states.set(agent.session, { key, threshold: config.thresholdPercent, nextAt: time + config.cooldownSeconds * 1000 })
+    globalNextAt = time + config.cooldownSeconds * 1000
+    const timer = setTimer(() => controller.abort(new Error('Automatic compaction timed out')), config.timeoutSeconds * 1000)
+    timer.unref?.()
+    let blocked = false
+    slot.done = (async () => {
+      try {
+        const result = await ctx.get('compaction').compactNow(agent, controller.signal)
+        if (result !== null) ctx.logger.info('dsh-ops auto-compact: compacted idle session history')
+      } catch (error) {
+        const code = error?.code
+        if (code === 'commit' || code === 'persistence') {
+          blocked = true
+          ctx.logger.warn('dsh-ops auto-compact: session requires inspection after a commit/save failure; automatic compaction is suspended until this component is reloaded')
+        } else if (!controller.signal.aborted && code !== 'busy' && code !== 'cancelled') {
+          // Do not log history, provider errors, paths or credentials.
+          ctx.logger.warn('dsh-ops auto-compact: compaction failed; automatic retry is backed off')
+        }
+      } finally {
+        clearTimer(timer)
+        // Suppress retries against our own replacement or bookkeeping records.
+        try {
+          states.set(agent.session, {
+            key: surfaceKey(agent.session), threshold: config.thresholdPercent, blocked,
+            nextAt: now() + config.cooldownSeconds * 1000,
+          })
+        } catch { /* disposed session */ }
+        globalNextAt = now() + config.cooldownSeconds * 1000
+        if (active.get(agent) === slot) active.delete(agent)
+      }
+    })()
+  }
+
+  function retire(agent) {
+    disposedAgents.add(agent)
+    active.get(agent)?.controller.abort(new Error('Agent disposed'))
+  }
+
+  async function dispose() {
+    closed = true
+    const slots = [...active.values()]
+    for (const slot of slots) slot.controller.abort(new Error('Automatic compaction component disabled'))
+    await Promise.allSettled(slots.map(slot => slot.done))
+  }
+  return { check, retire, dispose }
+}
+
+/** Keep this plugin's validated live references stable through Fiber.update. */
+export function installLiveConfigUpdates(ctx, config) {
+  ctx.on('internal/update', (candidate, _noSave, _next) => {
+    const values = resolveAutoCompactConfig(candidate)
+    const write = Symbol.for('cosmokit.volatile.write')
+    for (const [key, value] of Object.entries(values)) config[key][write](value)
+    try { ctx.emit('loader/volatile-update', Object.keys(values).map(key => [key])) }
+    catch { ctx.logger.warn('dsh-ops auto-compact: live config notification failed') }
+  })
+}
+
+/** Scoped listeners, abort and drain follow the host's teardown lifecycle. */
+export function apply(ctx, config = {}, { liveUpdates = true } = {}) {
+  resolveAutoCompactConfig(config)
+  if (liveUpdates) installLiveConfigUpdates(ctx, config)
+  const policy = createAutoCompactor(ctx, config)
+  const lastTurnSignals = new WeakMap()
+  ctx.effect(function* () {
+    yield () => policy.dispose()
+    yield ctx.on('agent/status', ({ agent, status }) => {
+      if (status === 'idle' && !lastTurnSignals.get(agent)?.aborted) policy.check(agent)
+    })
+    yield ctx.on('agent/turn-stopping', ({ agent, signal }) => {
+      lastTurnSignals.set(agent, signal)
+    })
+    yield ctx.on('agent/disposed', ({ agent }) => policy.retire(agent))
+    // Hot-enabling also covers already loaded idle sessions, without waking them.
+    ctx.inject(['agents'], inner => {
+      for (const agent of inner.get('agents').list()) policy.check(agent)
+    })
+  }, 'dsh-ops auto-compact lifecycle')
+}

package/packages/auto-compact/locale/en.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "Automatic context compaction",
+    "description": "Compact idle context above a configurable threshold (50% by default), without interrupting running tasks."
+  }
+}

package/packages/auto-compact/locale/zh.json

@@ -0,0 +1,6 @@
+{
+  "meta": {
+    "title": "上下文自动压缩",
+    "description": "上下文占用高于可设置阈值（默认 50%）时，在会话空闲后自动压缩，避免打断运行中的任务。"
+  }
+}

package/packages/auto-compact/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@dsh-ops/auto-compact",
+  "version": "0.1.0",
+  "description": "Idle-only automatic context compaction and row settings for dsh-ops.",
+  "license": "MIT",
+  "type": "module",
+  "main": "lib/index.js",
+  "exports": {
+    ".": "./lib/index.js",
+    "./client": "./lib/client.js",
+    "./package.json": "./package.json",
+    "./locale/*.json": "./locale/*.json"
+  },
+  "dsh": {
+    "client": {
+      "platform": "web",
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-plugin-manager"
+      ]
+    }
+  },
+  "files": ["lib", "locale", "LICENSE", "README.md"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/T-Auto/dsh-ops.git",
+    "directory": "packages/auto-compact"
+  },
+  "publishConfig": { "access": "public" }
+}