Skip to content
Back to search

dashi-taskboard

现代化可灵活嵌入的任务面板,支持 Codex、DeepSeek Harness

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/chuspeeism/dashi-taskboard with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/chuspeeism/dashi-taskboard'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/chuspeeism--dashi-taskboard/badge.svg)](/listings/chuspeeism--dashi-taskboard)

HTML

<a href="/listings/chuspeeism--dashi-taskboard"><img src="/api/listings/chuspeeism--dashi-taskboard/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Copy or symlink `skills/manage-taskboard` into the Codex skills directory, then start a new Codex task:

ln -s /absolute/path/to/codex-taskboard/skills/manage-taskboard \
  ~/.agents/skills/manage-taskboard

The desktop app keeps this same directory synchronized with its bundled Skill. The Skill teaches Codex to inspect an issue, move it to `in_progress`, use optimistic versions, verify the work, and then move it to `in_review`; it moves the issue to `done` only after the user explicitly confirms acceptance or asks to mark it complete.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 218 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. [English](README.md) | [简体中文](README.zh-CN.md)
  2. # Codex Taskboard
  3. A local-first issue board that runs in a browser and can be embedded in Codex through the standalone CDP launcher or its injection script. The same HTTP API powers the React UI and the `taskctl` CLI used by the bundled Codex Skill.
  4. ![Codex Taskboard product screenshot](docs/assets/codex-taskboard.png)
  5. ## Requirements
  6. - Node.js 22.22.3 or newer in the 22.x line, or 24.8 or newer
  7. - macOS App and DMG builds: Xcode Command Line Tools and Rust 1.88 or newer with the `aarch64-apple-darwin` and `x86_64-apple-darwin` targets. `npm install` installs the Tauri CLI used by this project.
  8. - Windows NSIS builds: the Microsoft Store Codex App, Rust 1.88 or newer, and Visual Studio Build Tools with the C++ workload and Windows SDK.
  9. ## Run locally
  10. ```bash
  11. npm install
  12. npm run build
  13. npm start
  14. ```
  15. Open <http://127.0.0.1:47823>. The SQLite database is stored at `.data/taskboard.sqlite`.
  16. For development with live frontend reload:
  17. ```bash
  18. npm run dev
  19. ```
  20. The Vite UI runs at <http://127.0.0.1:5173> and proxies API requests to the local service.
  21. ## Use the CLI
  22. Run it from the project:
  23. ```bash
  24. npm run taskctl -- project create \
  25. --id my-project \
  26. --name "My project" \
  27. --workspace-path /absolute/path/to/repository
  28. npm run taskctl -- issue create \
  29. --project my-project \
  30. --title "Implement the next slice" \
  31. --status todo \
  32. --priority high \
  33. --labels product,mvp
  34. ```
  35. Use `npm link` if you want `taskctl` on your shell path. Set `CODEX_TASKBOARD_URL` to point the CLI at another local or LAN service. Cloud deployments are configured through the **loopback companion** (device-local loopback service for auth and path mapping—not a chat persona) with `taskctl cloud login`.
  36. ## Install the Codex Skill
  37. Copy or symlink `skills/manage-taskboard` into the Codex skills directory, then start a new Codex task:
  38. ```bash
  39. ln -s /absolute/path/to/codex-taskboard/skills/manage-taskboard \
  40. ~/.agents/skills/manage-taskboard
  41. ```
  42. The desktop app keeps this same directory synchronized with its bundled Skill. The Skill teaches Codex to inspect an issue, move it to `in_progress`, use optimistic versions, verify the work, and then move it to `in_review`; it moves the issue to `done` only after the user explicitly confirms acceptance or asks to mark it complete.
  43. ## Embed in Codex
  44. ### Manual: use a dedicated CDP port
  45. Keep the existing Codex window open. From the Taskboard repository, start a second Codex instance with a dedicated CDP port:
  46. ```bash
  47. open -n -a /Applications/ChatGPT.app --args \
  48. --remote-debugging-port=9231 \
  49. --remote-allow-origins=http://127.0.0.1:9231
  50. ```
  51. After the new Codex window appears, run the injector in another terminal:
  52. ```bash
  53. CODEX_TASKBOARD_HOST=127.0.0.1 \
  54. npm run codex:inject -- --port 9231 --open
  55. ```
  56. Keep the injector terminal running while using the embedded panel. The original Codex window remains unchanged, and the new window receives the Taskboard sidebar entry. If port `9231` is occupied, use another port in both commands.
  57. ### Recommended: launch an independent Taskboard window with one command
  58. Keep existing Codex windows open and run:
  59. ```bash
  60. CODEX_TASKBOARD_HOST=127.0.0.1 npm run codex
  61. ```
  62. This starts the local Taskboard service when needed. It reuses an open Codex with a reachable CDP renderer, opens Taskboard in the native browser panel of an ordinary Codex without CDP, or launches the official macOS Codex app with an independent profile and loopback-only port `9231` when no Codex is open. It injects a native-looking Taskboard entry after Plugins when CDP is available and keeps watching both the service and replacement renderers. Keep this command running while using the embedded panel. The launcher does not modify `ChatGPT.app` or its `app.asar`.
  63. The source launcher writes its authenticated endpoint to `.data/launcher-runtime.json`. A `taskctl` command installed with `npm link` reads this file by default, so a normal shell and a Codex task opened from the panel use the same Taskboard service without an extra environment variable.
  64. ### macOS App: open and inject without a terminal
  65. For Tauri development, run:
  66. ```bash
  67. npm run app:dev
  68. ```
  69. To build the local App and DMG, install the two Rust targets once, then run the build:
  70. ```bash
  71. rustup target add aarch64-apple-darwin x86_64-apple-darwin
  72. npm run app:build
  73. ```
  74. Open `src-tauri/target/universal-apple-darwin/release/bundle/macos/Codex Taskboard.app` from Finder. The DMG is in `src-tauri/target/universal-apple-darwin/release/bundle/dmg/`. If you only want the stable App, download the current DMG from [GitHub Releases](https://github.com/chuspeeism/dashi-taskboard/releases/latest).
  75. The App contains its own Node runtime, Taskboard service, built web UI, Skill, CLI wrapper, and injection script. It starts the service, reuses an open Codex with a reachable CDP renderer, opens Taskboard in the native browser panel of an ordinary Codex without CDP, or launches the official Codex app when no Codex is open. It waits for the renderer, injects the sidebar entry when CDP is available, and opens the panel without showing a terminal window. The App can be copied away from this checkout; the target Mac only needs the official Codex app and does not need this repository, a system Node installation, or a separate Codex CLI installation. Taskboard data is stored in `~/Library/Application Support/Codex Taskboard`, and launcher output is written to `~/Library/Logs/Codex Taskboard/codex-taskboard-launcher.log`.
  76. ### Linux App: Ubuntu 24.04 x64 packages
  77. The first Linux desktop release supports Ubuntu 24.04 LTS on x64 only. Install the official ChatGPT desktop `.deb` first and confirm that `chatgpt` opens it. Then download either the Codex Taskboard `.deb` or `.AppImage` from [GitHub Releases](https://github.com/chuspeeism/dashi-taskboard/releases/latest). Replace `<file>` below with the downloaded filename.
  78. Install the `.deb` package:
  79. ```bash
  80. sudo apt install ./<file>.deb
  81. ```
  82. Or run the AppImage:
  83. ```bash
  84. chmod +x ./<file>.AppImage
  85. ./<file>.AppImage
  86. ```
  87. To build both packages on Ubuntu 24.04 x64, run:
  88. ```bash
  89. npm ci
  90. npm run app:build:linux:x64
  91. ```
  92. This first release does not support ARM64, Fedora, RPM packages, or other Linux distributions.
  93. ### Windows code signing
  94. For official Windows releases after the application is approved: **Free code signing provided by [SignPath.io](https://signpath.io/), certificate by [SignPath Foundation](https://signpath.org/).** Current Windows CI artifacts remain unsigned until that approval. See the [Code signing policy](docs/code-signing-policy.md), [Privacy policy](PRIVACY.md), and [Windows uninstall instructions](docs/windows-uninstall.md).
  95. The local build uses ad-hoc code signing for direct verification. A public macOS download still needs Developer ID signing and Apple notarization.
  96. ### Windows App: tray launcher and bundled Taskboard
  97. Install the official Codex App from the Microsoft Store. To build the current-user NSIS installer on Windows x64, run:
  98. ```powershell
  99. npm ci
  100. npm run app:build:windows
  101. ```
  102. The installer is written to `src-tauri/target/x86_64-pc-windows-msvc/release/bundle/nsis/`. It installs a tray launcher, bundled Node runtime, local service, built web UI, Skill, `taskctl.cmd`, and injection script. Taskboard data is stored in `%APPDATA%\Codex Taskboard`; logs are stored in `%LOCALAPPDATA%\Codex Taskboard\Logs`; the Skill is copied to `%USERPROFILE%\.agents\skills\manage-taskboard`.
  103. Windows CI artifacts are intentionally unsigned and do not auto-update. Review [the code-signing policy](docs/code-signing-policy.md) before distributing a build. See [Windows uninstall](docs/windows-uninstall.md) for retained-data behavior.
  104. Codex 26.715.52143 ships a renderer CSP that blocks arbitrary HTTP iframes. The launcher therefore enables CDP CSP bypass, reloads that renderer once, installs the document-start script, and waits until the Taskboard OOPIF is actually loaded. CDP is unauthenticated to other processes on the same machine, so only run trusted local code while the launcher is active.
  105. To inject into a Codex instance that was already launched with CDP by another method, run:
  106. ```bash
  107. npm run codex:inject -- --port 9229 --open
  108. ```
  109. This command also stays resident so the injected tab can restart Taskboard after a service exit. Stop it with `Ctrl-C`.
  110. The script adds a Taskboard entry to the Codex sidebar and renders the iframe across Codex's complete main workspace, including the contextual titlebar area so Taskboard's own header does not leave an empty strip. That full rectangular header is placed above Electron's draggable layer and marked `no-drag`; because the native contextual actions are suppressed while Taskboard is active, its own actions use their normal edge padding without an artificial right-side gap. The native sidebar stays mounted, while the previous page selection and contextual header are temporarily suppressed; choosing another Codex page restores them.
  111. “在对话中打开” selects the corresponding native Codex project when one is available and opens an unsent native composer with an `e-taskboard` instruction and the issue's actual identifier. The installed Skill is selected implicitly from that instruction, so the composer does not add a `$manage-taskboard` mention. A conversation is attributed only after it actually processes the issue: `taskctl` reads Codex's `CODEX_THREAD_ID` and records that ID on the issue or comment mutation. Recorded IDs are clickable through Codex's native route bridge. Each issue can bind either one Git branch or one worktree; the options are scanned from the selected Codex project's repository instead of being typed by hand. The integration uses Codex's existing project, composer, and route markers; it does not patch React, replace `fetch`, load private chunks, or edit Codex data files.
  112. To use a different UI origin, set `window.__CODEX_TASKBOARD_URL__` before the user script runs.
  113. ## Configuration
  114. | Variable | Default | Purpose |
  115. | --- | --- | --- |
  116. | `CODEX_TASKBOARD_HOST` | `0.0.0.0` | HTTP bind address; use `127.0.0.1` to disable LAN access |
  117. | `CODEX_TASKBOARD_PORT` | `47823` | Local HTTP port |
  118. | `CODEX_TASKBOARD_TRUSTED_ORIGINS` | unset | Comma-separated exact HTTPS origins allowed through a loopback reverse tunnel |
  119. | `CODEX_TASKBOARD_DATA_DIR` | `.data` | SQLite data directory |
  120. | `CODEX_TASKBOARD_URL` | `http://127.0.0.1:47823` | CLI API origin |
  121. `npm start` prints both the local URL and the available LAN URLs. Teammates on the same trusted network can open one of those LAN URLs and use the same taskboard service. Task, comment, and attachment changes are broadcast to every open client through server-sent events; reconnecting clients perform a full refresh so changes made while disconnected are not missed. A teammate using `taskctl` can point it at the shared service with `CODEX_TASKBOARD_URL=http://<host-ip>:47823`.
  122. LAN mode has no account authentication: anyone on the trusted local network who can reach the URL can read and write the taskboard. Public internet and cloud deployment require an authenticated deployment boundary.
  123. For a reverse tunnel that connects to the local listener, set `CODEX_TASKBOARD_TRUSTED_ORIGINS` to the tunnel's public HTTPS origin, for example `https://board.example.test`. Multiple origins are comma-separated. The variable cannot be empty, and duplicate origins (including normalized forms such as a trailing slash or default HTTPS port) are rejected at startup. Entries must otherwise be exact HTTPS origins; paths, queries, fragments, credentials, and wildcards are rejected. A reverse proxy or tunnel can preserve that public `Host`: Taskboard derives its canonical HTTPS origin and requires an exact configured match. If the browser supplies an `Origin`, that header is validated independently; the proxy must preserve it rather than fabricate one. Forwarded headers are not used for either decision. Configured public hosts and trusted origins can use ordinary Taskboard HTTP and realtime endpoints, but device-local capability routes remain unavailable even though the tunnel socket is loopback. Requests using only direct local or private-LAN hosts and origins keep their existing behavior.
  124. ## Share through Cloudflare
  125. For two trusted collaborators, the taskboard can run on Cloudflare with Worker Static Assets and API routes, D1 as the authoritative business database, and a private R2 bucket for attachments. The deployment uses HTTPS Basic Authentication with a shared password and refreshes open boards after a global revision changes.
  126. Each device keeps its own project checkout mapping and continues to use a local companion for Codex, Git/worktree, Skill, and MCP capabilities. Cloud mode never falls back to or double-writes the local SQLite database.
  127. See [Cloud collaboration](docs/cloud-collaboration.md) for owner deployment, existing GitHub installation setup, password rotation, local path mapping, and the one-time local-data migration flow.
  128. ## Verify
  129. ```bash
  130. npm run check
  131. ```
  132. This runs TypeScript checking, a production frontend build, the component tests, and the server/CLI/injection test suite.
  133. ## Task Markdown
  134. Task descriptions and comments support GFM, including tables and task lists. Fenced `mermaid` blocks are rendered as read-only diagrams after the viewer loads; the diagram source remains available when rendering fails. Markdown HTML comments, such as `<!-- trace-analysis:v1 ... -->`, are hidden from the rendered document. Raw HTML is not enabled.
  135. ## Acknowledgements
  136. Thanks to [Lingshan21](https://github.com/Lingshan21) for:
  137. - The parent-based project completion proposal and initial implementation in [#371](https://github.com/chuspeeism/dashi-taskboard/pull/371), which weighted top-level parent issues equally regardless of how many children each had.
  138. - The priority organization proposal and initial implementation in [#372](https://github.com/chuspeeism/dashi-taskboard/pull/372). The final board sorting controls were adapted to the maintainer's requirements instead of adopting the proposed priority swimlanes.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.