iPolloWork/external-plugins/deepseek-harness/video-studio

One-Line Pitch

deepseek-ivideo injects iPolloWork's Video Studio as a native Video view into DeepSeek Harness, allowing you to have AI draft or modify entire videos within conversations, apply 27 built-in templates, and trigger precise Ask AI modifications for selected elements on the canvas, ultimately exporting the final footage.

Core Capabilities

• Provides a native Video view in the DeepSeek Harness conversation tab bar, alongside Design and PPT views
• Allows AI to fully generate or extensively modify videos through conversation, and writes changes to the actual HyperFrames project file in the current workspace
• After selecting titles, images,素材 (assets), or other elements on the canvas, trigger precise modification requests with Ask AI—the plugin only prepares drafts without auto-sending
• Built-in 27 editable video templates that can be applied to the current session project with one click, with automatic rollback on failure
• Provides ipollowork_video_validate model tool for structured validation of editable videos in the current session
• Each session corresponds to an independent HyperFrames preview process, with all leases automatically recycled after 60 seconds and automatic fallback on port conflicts
• Exports videos as finished pieces based on HyperFrames native export capability, with canvas operations directly applied to HTML/CSS/asset files

Technical Implementation

• Languages: TypeScript + React (Studio frontend, Vite build) + Node.js (HTTP bridging and runtime process management)
• Key Dependencies: @deepseek-ai/cordis (plugin injection and effects), @deepseek-ai/dsh-host-webserver (route registration), @deepseek-ai/dsh-tools (model tool registration), @deepseek-ai/dsh-workspace (workspace parsing), @deepseek-ai/dsh-client-ui-conversation (frontend conversation view slot)
• Architecture Pattern: The server injects a plugin named ipollowork-video-studio via cordis.patch.yml, registers webServer routes under the /ipollowork-video prefix during the apply phase, connecting static resources, template directories, project initialization, and validation tools to the host; simultaneously injects client code into the Harness Web via dsh.client.inject, registering a conversation.view slot in conversations to render the iframe hosting Studio; Studio internally reuses the VideoPanel from the iPolloWork main project and bridges to host APIs via createDeepSeekVideoStudioHost
• Entry Files: src/index.ts (server registration and HTTP API), src/client.tsx (frontend Video view), studio/src/main.tsx (Studio internal React application), stage-hyperframes-runtime.mjs (copies vendor/hyperframes local build artifacts to lib/hyperframes at packaging time, runtime only calls embedded cli.js)

Use Cases

Suitable for users who need to directly produce editable videos, marketing clips, social media content, or teaching segments within the DeepSeek Harness workspace. The pain point is that previously only one-time videos or screenshots could be obtained in conversations, with no way to continue fine-tuning individual elements; this plugin keeps the real HyperFrames project in video/<sessionId>/ and allows AI generation, direct canvas editing, and element-level Ask AI to alternate seamlessly.

Prerequisites & Compatibility

Installation

dsh plugin --profile web add github:Devin-AXIS/iPolloWork/external-plugins/deepseek-harness/video-studio

Configuration

This plugin requires no user-level configuration. After installation, the plugin is injected into the host as ipollowork-video-studio (cordis.patch.yml), automatically registers the Video view in the DSH Web client, uses a 32-byte random token to protect iframe communication and API calls, and all read/write operations are restricted to the video/<sessionId>/ directory within the current workspace.

FAQ

Q: What is the relationship between deepseek-ivideo and the iPolloWork main project?

A: deepseek-ivideo is a Video sub-plugin separately published by iPolloWork for DeepSeek Harness—the package.json name is deepseek-ivideo, containing only the browser resources needed for the Video view; installing it does not download or launch the iPolloWork desktop client, nor does it pull in the two independent plugins Design (deepseek-idesign) and PPT (deepseek-ippt) together.

Q: Where are video projects saved?

A: All files are directly written to the video/<sessionId>/ directory of the currently registered workspace in DeepSeek Harness (packages/types/src/hyperframes-project.ts:14-16 / src/runtime.ts:234-247), including index.html, manifest.json, brief.json, and other real editable files, isolated from iDesign's design/ and iPPT's design/<sessionId>-ippt/ directories to prevent mutual overwrites.

Q: Will Design or PPT views be automatically included after installation?

A: No. Video template filtering only allows templates with surface === "video" and category === "video" (src/index.ts:61-64); website, poster, and report templates are provided by the independent deepseek-idesign plugin, and PPT templates are provided by deepseek-ippt; the project directories of these three plugins are isolated from each other.

Q: Does Ask AI automatically send messages?

A: No. Ask AI only organizes the relative path, positioning info, text, assets, and styles of the current video project or selected elements into a conversation draft and fills it into the Harness input box (src/client.tsx:20-30), waiting for user confirmation before manually sending—this prevents AI from auto-submitting and causing uncontrollable changes.

Q: Will multiple people editing simultaneously overwrite each other's work?

A: No. Video file writes go through studio-host's writeStudioText, attached with baseUpdatedAt; if a file has been modified since last load, it returns a 409 conflict prompt for the user to reload (studio-host/src/http.ts:161-163); writes themselves use temporary files + rename for atomic replacement, avoiding half-written states.

Q: Why doesn't the first version include voice cloning and Design System drawer?

A: The first version explicitly disables voice and designSystem feature toggles in Studio (studio/src/main.tsx:48-54), with the branding title fixed as iVideo by iPolloWork; these are global capabilities of the iPolloWork main project and are not exposed to the DeepSeek Harness host in the current version—only Video templates, timeline, editing, preview, and export capabilities are retained.

Q: How to uninstall?

A: Run dsh plugin --profile web remove deepseek-ivideo. After uninstallation, the Video view will disappear from the conversation tab bar, but files in video/<sessionId>/ in the workspace will not be automatically deleted—please manually clean up if no longer needed.

Difficulty Level

Beginner — No configuration required after installation; you can select the Video view in conversations to start creating. AI generation, canvas fine-tuning, and Ask AI interactions can all be completed in the same interface without writing code or modifying config files; template application, validation, and export are all triggered via built-in buttons in Studio.

Known Issues & Limitations

• First version does not include voice cloning, voice settings, or Design System drawer: Studio has features.voice and features.designSystem explicitly set to false (studio/src/main.tsx:48-54)—users needing these capabilities must use the iPolloWork desktop client.
• Can only read/write video/<sessionId>/ subdirectories: All APIs force path restriction to the video/ prefix via safeRelativePath (src/index.ts:144-164 / studio-host/src/http.ts:46-60); other workspace directories are not accessible by the plugin; cross-workspace symlinks are also rejected (studio-host/src/http.ts:80-95).
• Single file size limit 4 MB: Text file reads/writes like index.html in video projects are constrained by MAX_TEXT_BYTES = 4 * 1024 * 1024 (src/index.ts:43), different from iDesign/iPPT's 20 MB; HTTP request body limit remains 20 MB (studio-host/src/http.ts:10, 187), returns 413 when exceeded.
• Session ID format restricted: Must match ^[A-Za-z0-9_-]{1,128}$ (src/index.ts:42)—session IDs that are too long or contain special characters return 400 directly.
• Port allocation in 3100-3900 range by hash modulo: Each sessionId derives a fixed local port (packages/types/src/hyperframes-project.ts:1-8), probing up to 32 ports backward for available slots; if all are occupied, startup fails (src/runtime.ts:21, 258-307).
• Runtime process idle timeout: All leases are automatically recycled via SIGTERM after 60 seconds, startup timeout cap is 45 seconds (src/runtime.ts:19-22, 405-410).
• Embedded HyperFrames runtime version differs from npm public release: The release package copies vendor/hyperframes local build artifacts (current source version 0.7.60) to lib/hyperframes/ via stage-hyperframes-runtime.mjs at packaging time; it does not fetch a similarly named package from npm at install time; users wanting to upgrade must wait for the main repo sync and re-publish (package.json:66 / stage-hyperframes-runtime.mjs:7-47).
• Validation tool timeout 120 seconds: ipollowork_video_validate aborts the underlying process after 120 seconds (src/index.ts:209-237)—highly complex projects need segmented validation or simplified structure.

English · 简体中文 · 繁體中文 · 日本語

The enterprise-grade, local-first Agent Workbench for people and agent teams—one workspace for multiple agent engines, one unified system for plugins and Skills, multi-agent projects and tasks, and editable creation across code, documents, presentations, websites, design, and video.

https://github.com/user-attachments/assets/201b561a-22ec-4c8e-a4e8-f34172cf0aa3

iPolloWork is the unified workspace layer for the next agent-native way of working. It does not split projects or extensions by runtime: teams coordinate agents, tasks, schedules, plugins, Skills, tools, execution, and editable outputs from one control surface. Describe the outcome; agents plan and execute; your team reviews progress, approves actions, and keeps editing the result in the same place.

iPolloWork is not positioned as a replacement for a single coding agent. It connects Codex, DeepSeek Harness, OpenCode, and future agent runtimes through explicit compatibility boundaries while preserving the native strengths of each ecosystem. Coding is only the starting point: when the output is a deck, web page, visual design, or video, it remains editable instead of becoming a finished file or a chat transcript.

What makes it different

• One workbench across agent engines — use Codex, DeepSeek Harness, OpenCode, and future runtimes without rebuilding the project experience around each engine.
• One global extension system — install, enable, update, and uninstall portable plugins, Skills, agents, commands, services, and authorization once; optional engine-native bindings stay behind the same lifecycle.
• Project-native human-agent collaboration — give people and agents one shared project view for responsibilities, tasks, schedules, execution health, and results instead of scattering work across isolated chats.
• One editable production loop — move from code to documents, websites, presentations, design, and video while keeping text, images, layouts, timelines, and scenes editable after generation.
• Local and enterprise control — run locally, bring your own model or provider, review permissions and execution, and connect organization services only when a team needs them.

Agent runtime compatibility

OpenCode is the default local execution runtime today. DeepSeek Harness (DSH) is integrated as an optional peer runtime and subagent delegation target, while Codex connects through the ipollowork-ui-mcp control surface. MCP is the integration protocol for that path, not another agent engine alongside Codex, DSH, and OpenCode. These paths share the workbench without pretending that every runtime has the same native capabilities.

The collaboration model keeps iPolloWork as the project workspace: a task can delegate bounded work to DSH subagents when useful, then bring structured progress and results back into the same project. Each runtime retains its own agents, Skills, plugins, and execution model.

Run iPolloWork creative plugins directly in DeepSeek Harness

DeepSeek Harness users can install iPolloWork's native Design, PPT, and Video views into the DSH Web UI and start them from any project directory:

npx @deepseek-ai/dsh plugin --profile web add deepseek-idesign deepseek-ippt deepseek-ivideo
npx @deepseek-ai/dsh web

Open http://127.0.0.1:3080, start a conversation, and choose Design, PPT, or Video. If the dsh command is already installed, replace npx @deepseek-ai/dsh with dsh. DeepSeek Harness is currently a developer preview, so plugin compatibility follows its active release line.

Install iPolloWork

Download the desktop app

Official installers are published on GitHub Releases. If you prefer a manual download, choose the file that matches both your operating system and CPU:

The macOS .zip and Linux .tar.gz files are portable/update artifacts; most users should choose .dmg, .exe, or .AppImage. If the Releases page does not yet contain an installer for your system, run or package the app from source below.

Installation after downloading:

• macOS: open the .dmg, then drag iPolloWork into Applications.
• Windows: run the .exe installer. A locally built, unsigned installer may trigger Microsoft Defender SmartScreen.
• Linux: make the AppImage executable with chmod +x ipollowork-*.AppImage, then run it. The .tar.gz package can be extracted and run without installation.

Requirements for source development and packaging

• Git
• Node.js 22 or newer
• pnpm 11, enabled through Corepack with corepack enable
• Bun 1.3.10 or newer, used to build the local Orchestrator sidecar
• macOS: Xcode Command Line Tools (xcode-select --install)
• Windows: Visual Studio 2022 Build Tools with Desktop development with C++ and the Windows SDK; use PowerShell or Command Prompt
• Linux: a standard Electron build environment with a C/C++ toolchain, Python 3, pkg-config, and the desktop libraries required by Electron; the release build uses Ubuntu 22.04

OpenCode is downloaded and prepared as a separate sidecar during the first desktop build. iPolloWork does not fork or rewrite OpenCode, and OpenCode can continue to be upgraded independently.

Start from source

macOS and Linux

git clone https://github.com/Devin-AXIS/iPolloWork.git
cd iPolloWork
corepack enable
./ipollowork setup
./ipollowork dev

Windows PowerShell

git clone https://github.com/Devin-AXIS/iPolloWork.git
Set-Location iPolloWork
corepack enable
.\ipollowork.cmd setup
.\ipollowork.cmd dev

The setup command installs the locked workspace dependencies. The dev command prepares the OpenCode and Orchestrator sidecars, starts the UI, and opens the Electron desktop client. Development mode uses isolated iPolloWork/OpenCode state and does not overwrite the user's normal OpenCode configuration.

Development commands

Windows development builds do not register the production ipollowork:// handler automatically. When testing Cloud sign-in through an external browser, use the repository's protocol switcher and restore the production handler when you finish. See Windows protocol switching.

Build and package

There are three different build levels:

macOS and Linux

./ipollowork check
./ipollowork package:dir
./ipollowork package

Windows PowerShell

.\ipollowork.cmd check
.\ipollowork.cmd package:dir
.\ipollowork.cmd package

All outputs are written to apps/desktop/dist-electron/:

package is the local release command. It keeps the App, Desktop, Orchestrator, and Server versions in sync, and uses the sequence 0.1.0 through 0.99.0, then 1.0.0 (the source checkout starts at the unshipped baseline 0.0.0). Use ./ipollowork package --dry-run to inspect the next version, or --skip-check only when the checks have already passed. Local packaging never commits, tags, pushes, or publishes a release.

• macOS: .dmg, .zip, and an unpacked .app
• Windows: NSIS .exe and win-unpacked/
• Linux: .AppImage, .tar.gz, and linux-unpacked/

Local packaging targets the machine's current operating system and CPU architecture. Use the GitHub release workflow to produce the complete signed/notarized matrix for macOS ARM64/x64, Windows ARM64/x64, and Linux ARM64/x64. Local packages are unsigned unless the appropriate Apple or Windows signing credentials are supplied; they are suitable for development testing but should not be presented as official releases.

Connect to iPolloCloud

Start your local iPolloCloud control plane first, then run:

./ipollowork dev:cloud http://localhost:3100

This command creates an isolated development profile, points authentication and Cloud APIs at the supplied URL, and requires Cloud sign-in. It does not change the normal local iPolloWork profile. A remote or self-hosted Cloud URL works the same way:

./ipollowork dev:cloud https://cloud.example.com

Architecture boundary

Codex / MCP clients ── ipollowork-ui-mcp ──> iPolloWork desktop/UI
                                                   │
                                                   ├── local API ──> Engine Protocol ──> OpenCode (default)
                                                   │                               └──> DeepSeek Harness (optional)
                                                   └── optional account/control requests ──> iPolloCloud

• Agent execution, task state, and streaming are normalized at the shared engine boundary while engine-native behavior remains inside its adapter.
• Portable Skills, plugins, MCP servers, and project capabilities use one lifecycle; engine-specific enhancements stay optional.
• Codex compatibility currently uses the MCP control surface rather than claiming a native Codex engine adapter.
• iPolloCloud handles identity, organizations, entitlements, hosted worker lifecycle, administration, and commercial Apps.
• The Cloud connection is optional. Local iPolloWork works without an account or commercial service.
• OpenCode and DeepSeek Harness remain independent components and can continue to evolve without turning iPolloWork into a fork of either runtime.

Repository layout

• apps/app — shared React user interface
• apps/desktop — Electron desktop shell and packaging
• apps/server — iPolloWork server API
• apps/orchestrator — headless runtime orchestration
• packages — shared types, components, docs, and integrations
• docs — maintained engineering notes, platform guides, and generated reports
• evals — executable product flows and validation tooling
• examples — complete example plugin packages
• external-plugins — independently released plugins for external agent hosts
• packaging — release and installer metadata
• scripts — development, build, audit, and release automation
• specs — product and architecture specifications
• vendor — pinned third-party source that is built as part of iPolloWork

Contributing

Read AGENTS.md, docs/governance.md, CONTRIBUTING.md, SECURITY.md, and apps/app/src/react-app/ARCHITECTURE.md before making product changes. Run the narrow relevant test first, followed by:

./ipollowork check
git diff --check

See CONTRIBUTING.md, CODE_OF_CONDUCT.md, and SECURITY.md for contribution, community, and security policies.

Star History

License

iPolloWork uses the iPolloWork Source Available License 1.0:

• Free only for individual personal self-use and for small internal use by fewer than three total users.
• Prior written authorization is required for any use by three or more users, regardless of whether the use is personal, internal, commercial, non-commercial, individual, or organizational.
• Prior written authorization is required for any sale, resale, paid service, SaaS, hosting, white-label distribution, marketplace use, or customer-facing use, regardless of whether it is done by an individual or a company.
• The iPolloWork name, logo, and product attribution must remain visible in user-facing frontend displays unless prior written authorization expressly permits different branding.
• Separately licensed third-party components and code previously released under MIT retain their original licenses and existing rights.

See LICENSE for the controlling terms and LICENSES/MIT.txt for the historical MIT notice. This is a source-available license, not an OSI-approved open-source license.