side project is not funny

xsro · xsro · commit 13e261b93c51 · 2025-03-14T13:59:43.000+08:00
diff --git a/masm-tasm/.vscode/launch.json b/masm-tasm/.vscode/launch.json
@@ -17,7 +17,7 @@
 			"outFiles": [
 				"${workspaceFolder}/dist/**/*.js"
 			],
-			"preLaunchTask": "${defaultBuildTask}"
+			"preLaunchTask": "npm: compile-web"
 		},
 		{
 			"name": "Run Web Extension ",
diff --git a/masm-tasm/package.json b/masm-tasm/package.json
@@ -251,6 +251,17 @@
           "default": true,
           "description": "%config.savefirst%"
         },
+        "masmtasm.jsdos.ignore": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            },
+            "default": [
+              "\\.git",
+              "\\.vscode",
+              "node_modules"
+            ]
+          },
         "masmtasm.language.programmaticFeatures": {
           "type": "boolean",
           "default": true,
diff --git a/masm-tasm/resources/t/.jsdos/dosbox.conf b/masm-tasm/resources/t/.jsdos/dosbox.conf
diff --git a/masm-tasm/src/emulators/bundle.ts b/masm-tasm/src/emulators/bundle.ts
@@ -0,0 +1,109 @@
+//methods for manipute jsdos-bundles
+import * as JSZip from "jszip";
+import * as vscode from "vscode";
+
+const fs = vscode.workspace.fs;
+
+export interface MountFs{
+    type:"fs";
+    dir: vscode.Uri; 
+    disk: string 
+    watch?:boolean
+}
+
+export interface MountZip{
+    type:"zip";
+    zip:JSZip|Uint8Array;
+    root:string;
+    disk:string;
+}
+
+export type MountOption=MountFs|MountZip
+
+export interface CreateBundleOptions {
+  sample?: string;
+  boxConf?: string;
+  mount?: MountOption[];
+}
+
+// Copy function
+async function copyDirectory(sourceZip: JSZip, sourceDir: string, targetZip: JSZip, targetDir: string) {
+    // Iterate through all files in the source JSZip
+    for (const [relativePath, file] of Object.entries(sourceZip.files)){
+        if (relativePath.startsWith(sourceDir)) {
+            // Calculate the relative path of the target file
+            const newRelativePath = relativePath.replace(sourceDir, targetDir);
+            // If it's a directory, create a corresponding directory in the target JSZip
+            if (file.dir) {
+                targetZip.folder(newRelativePath);
+            } else {
+                // If it's a file, read the file content and create the same file in the target JSZip
+                const content=await file.async('uint8array')
+                targetZip.file(newRelativePath, content);
+            }
+        }
+    }
+    return targetZip;
+}
+
+/**create a jsdos bundle file by add new files to the sample.
+ * powered by https://stuk.github.io/jszip/
+ */
+export async function createBundle({
+  sample,
+  boxConf,
+  mount,
+}: CreateBundleOptions): Promise<JSZip> {
+  const zip = new JSZip();
+  if (sample) {
+    const zipdata = await fs.readFile(vscode.Uri.file(sample));
+    await zip.loadAsync(zipdata);
+  }
+
+  zip.file(".jsdos/dosbox.conf", boxConf ? boxConf : "");
+
+  if (mount) {
+    for (const m of mount) {
+        if(m.type==="fs"){
+            await allFiles(m.dir, async (uri: vscode.Uri) => {
+                const arr = await fs.readFile(uri);
+                const dst =
+                  m.disk + uri.path.replace(m.dir.path, "");///home/web_user
+                zip.file(dst, arr);
+              });
+        }
+        if (m.type==="zip"){
+            if(m.zip instanceof Uint8Array){
+                const source=await JSZip.loadAsync(m.zip)
+                await copyDirectory(source,m.root,zip,m.disk)
+            }else if(m.zip instanceof JSZip){
+                await copyDirectory(m.zip,m.root,zip,m.disk)
+            }
+        }
+    }
+  }
+
+  return zip;
+}
+
+async function allFiles(
+  dir: vscode.Uri,
+  callback: (file: vscode.Uri) => Promise<void>
+) {
+  const dirs = await fs.readDirectory(dir);
+  const r: string[] | undefined = vscode.workspace
+    .getConfiguration("masmtasm")
+    .get("jsdos.ignore");
+  const regs = r ? r.map((val) => new RegExp(val)) : [/\.git/, /\.vscode/];
+  for (const [term, type] of dirs) {
+    const uri = vscode.Uri.joinPath(dir, term);
+    if (regs.some((val) => term.match(val))) {
+      continue;
+    }
+    if (type === vscode.FileType.File) {
+      await callback(uri);
+    } else if (type === vscode.FileType.Directory) {
+      await allFiles(uri, callback);
+    }
+  }
+}
diff --git a/masm-tasm/src/emulators/jsdos-ci.ts b/masm-tasm/src/emulators/jsdos-ci.ts
@@ -30,7 +30,7 @@ class JsdosTerminal implements vscode.Pseudoterminal {
         this.writeEmitter.fire('\x1b[31mJSDos\x1b[0m\r\nhello');
     }
     close(): void {
-        this.ci.exit();
+        // this.ci.exit();
     }
     input = "";
     handleInput?(data: string): void {
@@ -66,20 +66,24 @@ function getWebviewContent(webview: vscode.Webview, extensionUri: vscode.Uri) {
 
 
 class Manager {
-    ci: CommandInterface | undefined = undefined;
+    hasCi: {ci: CommandInterface|undefined}={ci:undefined};
     terminal:vscode.Terminal|undefined=undefined;
-    updateci(ci: CommandInterface) {
-        const bar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
-        bar.command = 'masmtasm.emulatorStatus';
-        bar.text = `jsdos`;
-        bar.show();
+    shell:utils.Shell|undefined=undefined;
+    bar = vscode.window.createStatusBarItem(vscode.StatusBarAlignment.Left);
+    updateci(hasCi:{ci: CommandInterface}) {
+        this.bar.command = 'masmtasm.emulatorStatus';
+        this.bar.text = `jsdos`;
+        this.bar.show();
+        this.bar.color=new vscode.ThemeColor("activityBar.activeBackground")
 
-        this.ci = ci;
-        const pty = new JsdosTerminal(this.ci);
+        this.hasCi = hasCi;
+        const pty = new JsdosTerminal(hasCi.ci);
         this.terminal=vscode.window.createTerminal({ name: "jsdos", pty, });
+        this.shell=pty.shell
     }
     webview(context:vscode.ExtensionContext) {
-        if (this.ci) {
+        let ci=this.hasCi.ci;
+        if (ci) {
             const panel = vscode.window.createWebviewPanel(
                 "jsdos",
                 "jsdos panel",
@@ -95,10 +99,10 @@ class Manager {
 
             panel.webview.postMessage({
                 command: "ci",
-                width: this.ci?.width(),
-                height: this.ci?.height()
+                width: ci?.width(),
+                height: ci?.height()
             });
-           this.ci?.events().onFrame((rgb, rgba) => {
+           ci?.events().onFrame((rgb, rgba) => {
                 panel.webview.postMessage({
                     command: 'rgb',
                     time: new Date().getTime(),
@@ -114,13 +118,13 @@ class Manager {
                             return;
                         case 'keyup':
                             const up = utils.htmlKey2jsdos(message.code);
-                            if (up && this.ci)
-                                this.ci.sendKeyEvent(up, false);
+                            if (up && ci)
+                                ci.sendKeyEvent(up, false);
                             return;
                         case 'keydown':
                             const down = utils.htmlKey2jsdos(message.code);
-                            if (down && this.ci)
-                                this.ci.sendKeyEvent(down, true);
+                            if (down && ci)
+                                ci.sendKeyEvent(down, true);
                             return;
                     }
                 },
@@ -137,7 +141,7 @@ export const manager=new Manager();
 
 export function activate(context: vscode.ExtensionContext): void {
     async function statusBarCommand() {
-        const items = ["show jsdos view", "show terminal"];
+        const items = ["show jsdos view", "show terminal","exit"];
     
         const placeHolder = 'manipulate emulator';
         const seleted = await vscode.window.showQuickPick(items, { placeHolder });
@@ -147,6 +151,12 @@ export function activate(context: vscode.ExtensionContext): void {
         if(seleted===items[1]){
             manager.terminal?.show();
         }
+        if(seleted===items[2]){
+            manager.hasCi.ci?.exit()
+            manager.hasCi.ci=undefined
+            manager.bar.hide()
+            manager.terminal?.hide()
+        }
     }
     const disposable = vscode.commands.registerCommand('masmtasm.emulatorStatus', statusBarCommand);
     context.subscriptions.push(disposable);
diff --git a/masm-tasm/src/emulators/jsdos.ts b/masm-tasm/src/emulators/jsdos.ts
@@ -1,34 +1,28 @@
 import { ExtensionContext, ExtensionMode, Uri } from "vscode";
+import * as vscode from "vscode"
 import { ActionContext, AsmResult, ExecAction } from "../ASM/manager";
 import { DosEmulatorType } from "../utils/configuration";
 import { CommandInterface, getEmulators,platform } from "emulators";
 import { manager } from "./jsdos-ci";
+import { createBundle } from "./bundle";
+import { XhrOptions } from "emulators/dist/out/impl/http";
+
 platform.current.node_require=function(url:string){
     return __non_webpack_require__(url);
 };
-
-const TEST_STRING="XDRGS";
-const config={
-    dosboxConf: `[autoexec]
-echo ${TEST_STRING}
-`,
-    jsdosConf: {
-        version: "",
-    },
-};
-
-
+const request=platform.current.httpRequest
+platform.current.httpRequest=function(url:string,options:XhrOptions){
+    return request(url,options)
+}
 
 class JsdosRuntime{
     emulators;
     ci:CommandInterface|undefined;
     constructor(pathprefix:string){
         this.emulators=getEmulators(pathprefix);
-        const a=__non_webpack_require__(pathprefix+"wdosbox.js");
-        console.log(a);
     }
-    async run(){
-        this.ci=await this.emulators.dosboxDirect(config,);
+    async run(FS:Uint8Array){
+        this.ci=await this.emulators.dosboxDirect(FS,);
     }
 }
 
@@ -44,10 +38,25 @@ export class JSDosHost implements ExecAction{
             }else{
                 throw new Error("not implemented");
             }
-            await runtime.run();
-            if(runtime.ci){
-                manager.updateci(runtime.ci);
+
+            const source=await vscode.workspace.fs.readFile(Uri.joinPath(context.extensionUri,"resources","MASM-v6.11.zip"))
+            const boxConf=`
+[AUTOEXEC]
+mount C ./C/
+c:
+`// disk name is not case sensitive but file path is
+            const bundle=await createBundle({boxConf,mount:[{type:"zip",disk:"C","root":"C","zip":source}]});
+            console.log(bundle.files)
+            const data=await bundle.generateAsync({ type: "uint8array" })
+            await runtime.run(data);
+            if(runtime && runtime.ci){
+                manager.updateci(runtime as {ci:CommandInterface});
             }
+            vscode.workspace.fs.writeFile(Uri.joinPath(context.extensionUri,"resources","test.zip"),data)
+        }
+
+        if(manager.hasCi.ci&&manager.terminal){
+            manager.shell?.exec("echo hello")
         }
         
         return {
diff --git a/masm-tasm/src/web/ASM.ts b/masm-tasm/src/web/ASM.ts
@@ -2,10 +2,8 @@ import * as vscode from "vscode";
 import { emulist } from "../emulators/main";
 import { ActionType } from "../utils/configuration";
 import { activateManager } from "../ASM/manager";
-import * as statusBar from '../emulators/jsdos-ci'
 
 export async function activate(context: vscode.ExtensionContext) {
-    statusBar.activate(context);
 
     const execAction = activateManager(context, emulist);
 

Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@`
`17`	`17`	`"outFiles": [`
`18`	`18`	`"${workspaceFolder}/dist/*/.js"`
`19`	`19`	`],`
`20`		`- "preLaunchTask": "${defaultBuildTask}"`
	`20`	`+ "preLaunchTask": "npm: compile-web"`
`21`	`21`	`},`
`22`	`22`	`{`
`23`	`23`	`"name": "Run Web Extension ",`