feat: Integrate c64u machine into c64u tree explorer

Author: cybersorcerer

CHANGELOG.md

@@ -2,12 +2,32 @@
 
 All notable changes to the "c64-vscode" extension will be documented in this file.
 
-## [Unreleased]
+## [0.5.3] - 2026-02-18
+
+### Added
+
+- **Machine Control in Tree View** — Machine section as a root node in the C64 Ultimate Tree View with directly clickable actions: Reset, Reboot, Pause, Resume, Power Off — no QuickPick menu required.
+- **Compile & Run button in Tree View title bar** — `$(cloud-upload)` button for Assemble, Upload and Run directly from the C64 Ultimate panel.
+- **Unmount Disk Image** — Renamed from "Unmount Drive" for clarity.
+- **Updated kickass_ls** — Bundles the latest version of the kickass_ls language server.
+
+### Changed
+
+- C64 Ultimate Tree View now has two root sections: **Machine** (with control actions) and **File System** (existing file browser).
+
+## [0.5.2] - 2026-02-18
 
 ### Added
 
 - **Language Server Settings UI** — All kickass_ls diagnostics and formatting options are now configurable via VS Code settings (search for "kickass_ls"). Changes take effect immediately without reload.
 - **GitHub Actions Release Workflow** — Automatically builds platform-specific VSIX files when a version tag is pushed.
+- **C64U toggle** — All C64 Ultimate commands, keybindings, Tree View and Activity Bar icon are now toggleable via the `c64u.enabled` setting (default: false).
+- **`.kasm` file extension** — Kick Assembler-specific extension to avoid conflicts with other assembler extensions (e.g. HLASM).
+
+### Fixed
+
+- **Extension activation** — Fixed VSIX packaging issue where `vscode-languageclient` dependency was excluded, causing the extension to silently fail to activate.
+- **Language Server activation** — Added pattern-based document selectors (`**/*.asm`, `**/*.kasm`) to ensure the language server activates even when another extension claims the `.asm` file association.
 
 ## [0.3.0] - 2026-02-07
 

README.md

@@ -31,15 +31,16 @@ All syntax highlighting and code analysis comes from the **kickass_ls** language
 
 Full integration with C64 Ultimate hardware via the `c64u` CLI tool:
 
-- **Tree View File Explorer** in the Activity Bar with drag-and-drop support
+- **Tree View** in the Activity Bar with two sections:
+  - **Machine** — directly clickable Reset, Reboot, Pause, Resume, Power Off actions
+  - **File System** — full file browser with drag-and-drop support
 - Open text files (`.asm`, `.bas`, `.seq`, `.txt`, `.cfg`, `.inc`, `.sym`, `.dbg`) directly in the editor — changes are automatically uploaded back to the C64 Ultimate on save
 - Open binary files (`.prg`, `.crt`, `.bin`, `.tap`, `.t64`, `.rel`, `.ko`) in the Hex Editor
 - Browse and navigate the C64 Ultimate filesystem
 - Upload, download, rename, copy, and delete files
 - Create directories and disk images (d64, d71, d81, g64, dnp)
 - Mount/unmount disk images on IEC drives
 - Run `.prg` files directly on hardware
-- Machine control (reset, reboot, pause, resume)
 - Interactive QuickPick-based file browser
 
 ## Prerequisites
@@ -195,13 +196,14 @@ If another extension claims the `.asm` file association, the language server sti
 
 ### C64 Ultimate Workflow
 
-1. Enable C64 Ultimate in settings and configure host/port
-2. Use `Ctrl+Shift+U` to assemble, upload, and run on real hardware
-3. Use the Tree View in the Activity Bar to browse files on the C64 Ultimate
-4. Click text files to edit them — changes are automatically uploaded on save
-5. Click binary files to view them in the Hex Editor
-6. Right-click for context actions (rename, copy, delete, mount, run)
-7. Drag and drop files to move them between directories
+1. Enable C64 Ultimate in settings (`c64u.enabled`) and configure host/port
+2. Use `Ctrl+Shift+U` or the `$(cloud-upload)` button in the Tree View title bar to assemble, upload, and run on real hardware
+3. Use the **Machine** section in the Tree View to reset, reboot, pause or power off the C64 directly
+4. Use the **File System** section to browse files on the C64 Ultimate
+5. Click text files to edit them — changes are automatically uploaded on save
+6. Click binary files to view them in the Hex Editor
+7. Right-click for context actions (rename, copy, delete, mount, run)
+8. Drag and drop files to move them between directories
 
 ## Commands
 
@@ -230,11 +232,21 @@ Access via Command Palette (`Cmd+Shift+P` / `Ctrl+Shift+P`):
 
 - **Open in Editor** — Open text/binary files in appropriate editor
 - **Run Program** — Run `.prg` files on C64 Ultimate
-- **Mount/Unmount** — Mount disk images on IEC drives
+- **Mount / Unmount Disk Image** — Mount disk images on IEC drives
 - **Download/Upload** — Transfer files to/from local machine
 - **Rename/Copy/Delete** — File management
 - **New Directory / Create Disk Image** — Create new items
 
+### Tree View Machine Section
+
+Click directly to execute without confirmation dialog:
+
+- **Reset** — Soft reset the C64
+- **Reboot** — Full reboot
+- **Pause** — Pause the machine
+- **Resume** — Resume from pause
+- **Power Off** — Power off the C64 Ultimate
+
 ## Building with Bundled Binaries
 
 To build the extension with bundled Go binaries:

package.json

@@ -2,7 +2,7 @@
   "name": "c64-vscode",
   "displayName": "C64 Assembler Development",
   "description": "Complete C64 development environment with Kick Assembler, LSP support, VICE emulator, and C64 Ultimate integration",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "publisher": "cybersorcerer",
   "license": "Apache-2.0",
   "repository": {
@@ -201,7 +201,7 @@
       },
       {
         "command": "c64u.treeview.unmount",
-        "title": "Unmount Drive",
+        "title": "Unmount Disk Image",
         "icon": "$(debug-disconnect)"
       },
       {
@@ -219,6 +219,11 @@
         "title": "Run Program",
         "icon": "$(play)"
       },
+      {
+        "command": "c64u.treeview.machine",
+        "title": "Machine Control",
+        "icon": "$(vm)"
+      },
       {
         "command": "c64u.treeview.openFile",
         "title": "Open in Editor",
@@ -555,6 +560,10 @@
         {
           "command": "c64u.treeview.openFile",
           "when": "false"
+        },
+        {
+          "command": "c64u.treeview.machine",
+          "when": "false"
         }
       ],
       "view/title": [
@@ -563,6 +572,11 @@
           "when": "view == c64u.fileExplorer",
           "group": "navigation"
         },
+        {
+          "command": "c64u.uploadAndRun",
+          "when": "view == c64u.fileExplorer",
+          "group": "navigation"
+        },
         {
           "command": "c64u.treeview.upload",
           "when": "view == c64u.fileExplorer",

src/c64u/service.ts

@@ -41,6 +41,15 @@ export class C64UService {
         await this.fileBrowserProvider.show();
     }
 
+    async executeMachineAction(action: string): Promise<void> {
+        const result = await executeC64U(['machine', action]);
+        if (result.success) {
+            vscode.window.showInformationMessage(`Machine ${action} executed`);
+        } else {
+            vscode.window.showErrorMessage(`Machine control failed: ${result.error}`);
+        }
+    }
+
     async showMachineControl(): Promise<void> {
         const actions = [
             { label: '$(debug-restart) Reset', value: 'reset' },

src/c64u/treeview.ts

@@ -3,6 +3,15 @@ import * as path from 'path';
 import { C64UClient } from './client';
 import { C64UFileOpenManager } from './file-open-manager';
 
+// Machine control actions shown as direct tree items
+const MACHINE_ACTIONS: { label: string; action: string; icon: string; description: string }[] = [
+    { label: 'Reset',     action: 'reset',    icon: 'debug-restart',  description: 'Soft reset' },
+    { label: 'Reboot',    action: 'reboot',   icon: 'refresh',        description: 'Full reboot' },
+    { label: 'Pause',     action: 'pause',    icon: 'debug-pause',    description: 'Pause machine' },
+    { label: 'Resume',    action: 'resume',   icon: 'debug-continue', description: 'Resume machine' },
+    { label: 'Power Off', action: 'poweroff', icon: 'circle-slash',   description: 'Power off' },
+];
+
 export class C64UFileSystemProvider implements vscode.TreeDataProvider<C64UTreeItem>, vscode.TreeDragAndDropController<C64UTreeItem> {
     private _onDidChangeTreeData: vscode.EventEmitter<C64UTreeItem | undefined | null | void> = new vscode.EventEmitter<C64UTreeItem | undefined | null | void>();
     readonly onDidChangeTreeData: vscode.Event<C64UTreeItem | undefined | null | void> = this._onDidChangeTreeData.event;
@@ -41,14 +50,36 @@ export class C64UFileSystemProvider implements vscode.TreeDataProvider<C64UTreeI
             )];
         }
 
+        // Root level: show Machine section and File System section
+        if (!element) {
+            return [
+                new C64UTreeItem('Machine', vscode.TreeItemCollapsibleState.Expanded, 'machine-root', '__machine__'),
+                new C64UTreeItem('File System', vscode.TreeItemCollapsibleState.Expanded, 'filesystem-root', '/'),
+            ];
+        }
+
+        // Machine section children: individual machine actions
+        if (element.itemType === 'machine-root') {
+            return MACHINE_ACTIONS.map(a => new C64UTreeItem(
+                a.label,
+                vscode.TreeItemCollapsibleState.None,
+                'machine-action',
+                `__machine__/${a.action}`,
+                undefined,
+                a.icon,
+                a.description
+            ));
+        }
+
+        // File System section children: existing file browsing logic
         try {
-            const targetPath = element ? element.resourcePath : '/';
+            const targetPath = element.itemType === 'filesystem-root' ? '/' : element.resourcePath;
             console.log(`[C64U TreeView] Loading children for: ${targetPath}`);
             const files = await this.client.listFiles(targetPath);
 
             // Add parent directory entry if not at root
             const items: C64UTreeItem[] = [];
-            if (targetPath !== '/' && !element) {
+            if (targetPath !== '/') {
                 const parentPath = targetPath.substring(0, targetPath.lastIndexOf('/')) || '/';
                 items.push(new C64UTreeItem(
                     '..',
@@ -90,7 +121,7 @@ export class C64UFileSystemProvider implements vscode.TreeDataProvider<C64UTreeI
             }
 
             // If directory is empty, show a friendly message
-            if (items.length === 0 && targetPath !== '/') {
+            if (items.length === 0) {
                 console.log(`[C64U TreeView] Directory ${targetPath} is empty`);
                 return [new C64UTreeItem(
                     'Empty directory',
@@ -196,7 +227,8 @@ export class C64UFileSystemProvider implements vscode.TreeDataProvider<C64UTreeI
         // Move each dragged item
         for (const item of draggedItems) {
             // Skip special items
-            if (item.itemType === 'parent' || item.itemType === 'message' || item.itemType === 'error') {
+            if (item.itemType === 'parent' || item.itemType === 'message' || item.itemType === 'error' ||
+                item.itemType === 'machine-root' || item.itemType === 'machine-action' || item.itemType === 'filesystem-root') {
                 continue;
             }
 
@@ -293,22 +325,34 @@ export class C64UFileSystemProvider implements vscode.TreeDataProvider<C64UTreeI
     }
 }
 
-type C64UItemType = 'directory' | 'diskimage' | 'diskimage-gcr' | 'program' | 'sid' | 'cartridge' | 'textfile' | 'binaryfile' | 'file' | 'parent' | 'message' | 'error';
+type C64UItemType = 'directory' | 'diskimage' | 'diskimage-gcr' | 'program' | 'sid' | 'cartridge' | 'textfile' | 'binaryfile' | 'file' | 'parent' | 'message' | 'error' | 'machine-root' | 'machine-action' | 'filesystem-root';
 
 export class C64UTreeItem extends vscode.TreeItem {
     constructor(
         public readonly label: string,
         public readonly collapsibleState: vscode.TreeItemCollapsibleState,
         public readonly itemType: C64UItemType,
         public readonly resourcePath: string,
-        public readonly fileSize?: number
+        public readonly fileSize?: number,
+        customIcon?: string,
+        description?: string
     ) {
         super(label, collapsibleState);
 
         this.contextValue = itemType;
         this.tooltip = this.buildTooltip();
-        this.iconPath = this.getIcon();
-        this.description = this.getDescription();
+        this.iconPath = customIcon ? new vscode.ThemeIcon(customIcon) : this.getIcon();
+        this.description = description ?? this.getDescription();
+
+        // Machine actions execute on click
+        if (itemType === 'machine-action') {
+            const action = resourcePath.replace('__machine__/', '');
+            this.command = {
+                command: 'c64u.treeview.machine',
+                title: label,
+                arguments: [action]
+            };
+        }
 
         // Make clickable items that navigate
         if (itemType === 'directory' || itemType === 'parent') {
@@ -317,7 +361,10 @@ export class C64UTreeItem extends vscode.TreeItem {
                 title: 'Navigate',
                 arguments: [this]
             };
-        } else if (C64UFileOpenManager.isOpenableFile(label)) {
+        } else if (itemType === 'filesystem-root') {
+            // File System root navigates to /
+            this.command = undefined;
+        } else if (C64UFileOpenManager.isOpenableFile(label) && itemType !== 'machine-action') {
             this.command = {
                 command: 'c64u.treeview.openFile',
                 title: 'Open File',
@@ -330,6 +377,15 @@ export class C64UTreeItem extends vscode.TreeItem {
         if (this.itemType === 'message' || this.itemType === 'error') {
             return this.label;
         }
+        if (this.itemType === 'machine-root') {
+            return 'C64 Ultimate Machine Control';
+        }
+        if (this.itemType === 'machine-action') {
+            return `Execute: ${this.label}`;
+        }
+        if (this.itemType === 'filesystem-root') {
+            return 'C64 Ultimate File System';
+        }
 
         let tooltip = `Path: ${this.resourcePath}`;
         if (this.fileSize !== undefined) {
@@ -341,6 +397,12 @@ export class C64UTreeItem extends vscode.TreeItem {
 
     private getIcon(): vscode.ThemeIcon {
         switch (this.itemType) {
+            case 'machine-root':
+                return new vscode.ThemeIcon('vm');
+            case 'machine-action':
+                return new vscode.ThemeIcon('gear');
+            case 'filesystem-root':
+                return new vscode.ThemeIcon('server');
             case 'directory':
                 return new vscode.ThemeIcon('folder');
             case 'parent':

src/extension.ts

@@ -136,6 +136,12 @@ export function activate(context: vscode.ExtensionContext) {
         })
     );
 
+    context.subscriptions.push(
+        vscode.commands.registerCommand('c64u.treeview.machine', async (action: string) => {
+            await c64uService!.executeMachineAction(action);
+        })
+    );
+
     // Start Language Server first
     startLanguageServer(context);
 
@@ -313,7 +319,10 @@ function startLanguageServer(context: vscode.ExtensionContext) {
         },
         initializationOptions: {
             settings: { kickass_ls: getKickassLsSettings() }
-        }
+        },
+        outputChannelName: 'Kick Assembler Language Server',
+        revealOutputChannelOn: 1, // RevealOutputChannelOn.Info
+        traceOutputChannel: vscode.window.createOutputChannel('Kick Assembler Language Server (Trace)')
     };
 
     // Create and start the language client