pinokiod 3.107.0 → 3.109.0

package/kernel/bin/caddy.js

@@ -23,6 +23,26 @@ class Caddy {
     }
   }
   async start() {
+    // if peer.https_active is true,
+    // 1. kill existing caddy
+    // 2. start caddy
+    if (!this.kernel.peer || !("https_active" in this.kernel.peer)) {
+      // wait until they are available
+      await new Promise((resolve, reject) => {
+        let interval = setInterval(() => {
+          console.log("wait until peer becomes available")
+          if (this.kernel.peer && "https_active" in this.kernel.peer) {
+            console.log("peer ready")
+            clearInterval(interval)
+            resolve()
+          }
+        }, 1000)
+      })
+    }
+    if (!this.kernel.peer.https_active) {
+      console.log("https_active false")
+      return
+    }
 //    console.log("Existing caddy pid?", this.kernel.processes.caddy_pid)
     let running = await this.running()
     console.log("Caddy running?", running)
@@ -31,6 +51,7 @@ class Caddy {
       console.log("kill existing caddy before restarting")
       await new Promise((resolve, reject) => {
         let interval = setInterval(() => {
+          console.log("CADDY_PID", this.kernel.processes.caddy_pid)
           if (this.kernel.processes.caddy_pid) {
             try {
               console.log("kill caddy", this.kernel.processes.caddy_pid)
@@ -39,10 +60,12 @@ class Caddy {
               clearInterval(interval)
               resolve()
             } catch (error) {
+              console.log("ERROR", error)
               clearInterval(interval)
               reject(error)
             }
           } else {
+            //clearInterval(interval)
             console.log("try killing existing caddy again in 1 sec")
           }
         }, 1000)
@@ -76,6 +99,7 @@ class Caddy {
       this.kernel.peer.announce()
       console.log("announced to peers")
 //      this.kernel.refresh(true)
+    } else {
     }
   }
   async install(req, ondata, kernel, id) {

package/kernel/bin/git.js

@@ -49,6 +49,13 @@ class Git {
     }
 
     await fs.promises.mkdir(this.kernel.path("scripts/git"), { recursive: true }).catch((e) => { })
+
+    let gitfork_path = path.resolve(this.kernel.homedir, "scripts/git/fork.json")
+    await fs.promises.copyFile(
+      path.resolve(__dirname, "..", "scripts/git/fork"),
+      gitfork_path
+    )
+
     let gitpush_path = path.resolve(this.kernel.homedir, "scripts/git/push.json")
     await fs.promises.copyFile(
       path.resolve(__dirname, "..", "scripts/git/push"),
@@ -106,6 +113,11 @@ class Git {
     if (!exists4) {
       return false; 
     }
+    let gitfork_path = path.resolve(this.kernel.homedir, "scripts/git/fork.json")
+    let exists5 = await this.kernel.api.exists(gitfork_path)
+    if (!exists5) {
+      return false; 
+    }
 
     if (this.kernel.platform === "darwin") {
       let gh_config_exists = await this.kernel.exists("config/gh")

package/kernel/environment.js

@@ -557,6 +557,82 @@ const init = async (options, kernel) => {
       }
     }
   }
+
+  const agentTemplatePath = kernel.path("prototype/system/AGENTS.md")
+  const agentTemplateExists = await kernel.exists(agentTemplatePath)
+  if (agentTemplateExists) {
+    const agentFiles = [
+      "AGENTS.md",
+      "CLAUDE.md",
+      "GEMINI.md",
+      "QWEN.md",
+      ".windsurfrules",
+      ".cursorrules",
+      ".clinerules"
+    ]
+    const structure_path = kernel.path("prototype/system/structure/clone")
+    const structure_content = await fs.promises.readFile(structure_path, "utf-8")
+    const rendered_recipe = await kernel.renderFile(agentTemplatePath, {
+      structure: structure_content,
+      examples: kernel.path("prototype/system/examples"),
+      browser_logs: kernel.path("logs/browser.log"),
+      PINOKIO_DOCUMENTATION: kernel.path("prototype/PINOKIO.md"),
+      PTERM_DOCUMENTATION: kernel.path("prototype/PTERM.md"),
+      app_root: root
+    })
+    for (const filename of agentFiles) {
+      const destination = path.resolve(root, filename)
+      const destinationExists = await kernel.exists(destination)
+      if (!destinationExists) {
+        await fs.promises.writeFile(destination, rendered_recipe)
+      }
+    }
+  }
+
+  const gitDir = path.resolve(root, ".git")
+  const gitDirExists = await kernel.exists(gitDir)
+  if (gitDirExists) {
+    const excludePath = path.resolve(gitDir, "info/exclude")
+    await fs.promises.mkdir(path.dirname(excludePath), { recursive: true })
+
+    let excludeContent = ""
+    try {
+      excludeContent = await fs.promises.readFile(excludePath, "utf8")
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error
+      }
+    }
+
+    const existingEntries = new Set(
+      excludeContent
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .filter(line => line.length > 0)
+    )
+
+    const entriesToEnsure = [
+      "ENVIRONMENT",
+      ".*",
+      "~*",
+      "/logs/",
+      "/cache/",
+      "/AGENTS.md",
+      "/CLAUDE.md",
+      "/GEMINI.md",
+      "/QWEN.md"
+    ]
+
+    const missingEntries = entriesToEnsure.filter(entry => !existingEntries.has(entry))
+    if (missingEntries.length > 0) {
+      let appendContent = ""
+      if (excludeContent.length > 0 && !excludeContent.endsWith("\n")) {
+        appendContent += "\n"
+      }
+      appendContent += missingEntries.join("\n") + "\n"
+      await fs.promises.appendFile(excludePath, appendContent)
+    }
+  }
   return {
     relpath,
     root_path: root,

package/kernel/git.js

@@ -67,41 +67,39 @@ class Git {
         display_name = `${name}/${gitRelPathSansGit}`
         main = false
       }
+      let gitRemote = null
       try {
-        let gitRemote = await git.getConfig({
+        gitRemote = await git.getConfig({
           fs,
           http,
           dir,
           path: 'remote.origin.url'
         })
-        repos.push({
-          main,
-          name: display_name,
-          gitPath,
-          gitRelPath,
-          gitParentPath,
-          gitParentRelPath,
-          dir,
-          url: gitRemote,
-        })
-        if (!this.mapping[gitRemote]) {
+      } catch (_) {}
+
+      const repoEntry = {
+        main,
+        name: display_name,
+        gitPath,
+        gitRelPath,
+        gitParentPath,
+        gitParentRelPath,
+        dir,
+      }
+      if (gitRemote) {
+        repoEntry.url = gitRemote
+      }
+      repos.push(repoEntry)
+
+      if (gitRemote && !this.mapping[gitRemote]) {
+        try {
           let head = await this.getHead(gitParentPath)
           this.mapping[gitRemote] = {
             main,
             path: gitParentPath,
             head 
           }
-        }
-      } catch (e) {
-        repos.push({
-          main,
-          name: display_name,
-          gitPath,
-          gitRelPath,
-          gitParentPath,
-          gitParentRelPath,
-          dir,
-        })
+        } catch (_) {}
       }
       this.dirs.add(dir)
     }

package/kernel/scripts/git/fork

@@ -0,0 +1,21 @@
+{
+  "run": [{
+    "when": "{{args.org}}",
+    "method": "shell.run",
+    "params": {
+      "path": "{{args.cwd}}",
+      "message": [
+        "gh repo fork --remote=true --clone=false --fork-name {{args.name}} --org {{args.org}}"
+      ]
+    }
+  }, {
+    "when": "{{!args.org}}",
+    "method": "shell.run",
+    "params": {
+      "path": "{{args.cwd}}",
+      "message": [
+        "gh repo fork --remote=true --clone=false --fork-name {{args.name}}"
+      ]
+    }
+  }]
+}

package/kernel/scripts/git/push

@@ -5,7 +5,7 @@
       "chain": "*",
       "path": "{{args.cwd}}",
       "message": [
-        "git push -u"
+        "git push -u origin"
       ]
     }
   }]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pinokiod",
-  "version": "3.107.0",
+  "version": "3.109.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/server/index.js

@@ -484,98 +484,112 @@ class Server {
     }
   }
   async getGit(ref, filepath) {
-    let dir = this.kernel.path("api", filepath)
-    let branches = await git.listBranches({ fs, dir });
-    // no branch, means no git repo => initialize
-    if (branches.length === 0) {
-      return {}
-//      const defaultBranch = 'main';
-//      await git.init({ fs, dir, defaultBranch });
-//      branches = await git.listBranches({ fs, dir });
-//      const current = await git.currentBranch({ fs, dir, fullname: false }) || defaultBranch;
-//      if (!branches.includes(current)) {
-//        branches.unshift(current);
-//      }
-//      if (!ref || ref === 'HEAD') {
-//        ref = current;
-//      }
-    }
-    let log = []
+    const dir = this.kernel.path("api", filepath)
+
+    let branchList = []
     try {
-      log = await git.log({ fs, dir, depth: 50, ref: ref }); // fetch last 50 commits
-      log.forEach((item) => {
+      branchList = await git.listBranches({ fs, dir })
+    } catch (_) {}
+
+    const collectLog = async (targetRef) => {
+      const entries = await git.log({ fs, dir, depth: 50, ref: targetRef })
+      entries.forEach((item) => {
         item.info = `/gitcommit/${item.oid}/${filepath}`
       })
-    } catch (e) {
-      console.log("Log error", e)
+      return entries
+    }
+
+    let log = []
+    let logError = null
+    if (ref) {
+      try {
+        log = await collectLog(ref)
+      } catch (error) {
+        logError = error
+      }
+    }
+    if (log.length === 0) {
+      try {
+        log = await collectLog('HEAD')
+      } catch (error) {
+        if (!logError) {
+          logError = error
+        }
+      }
+    }
+
+    let currentBranch = null
+    try {
+      currentBranch = await git.currentBranch({ fs, dir, fullname: false })
+    } catch (_) {}
+
+    let branches = []
+    if (branchList.length > 0) {
+      branches = branchList.map((name) => ({
+        branch: name,
+        selected: currentBranch ? name === currentBranch : false
+      }))
+      if (!currentBranch && log.length > 0) {
+        const headOid = log[0].oid
+        branches = [{ branch: headOid, selected: true }, ...branches.map((entry) => ({ ...entry, selected: false }))]
+        currentBranch = headOid
+      }
+    } else {
+      if (currentBranch) {
+        branches = [{ branch: currentBranch, selected: true }]
+      } else if (log.length > 0) {
+        const headOid = log[0].oid
+        branches = [{ branch: headOid, selected: true }]
+        currentBranch = headOid
+      }
+    }
+
+    if (!currentBranch && log.length > 0) {
+      currentBranch = log[0].oid
     }
 
-    let config = await this.kernel.git.config(dir)
+    if (branches.length === 0) {
+      branches = [{ branch: currentBranch || 'HEAD', selected: true }]
+    }
+
+    const config = await this.kernel.git.config(dir)
 
     let hosts = ""
-    let hosts_file = this.kernel.path("config/gh/hosts.yml")
-    let e = await this.exists(hosts_file)
-    if (e) {
-      hosts = await fs.promises.readFile(hosts_file, "utf8")
+    const hostsFile = this.kernel.path("config/gh/hosts.yml")
+    if (await this.exists(hostsFile)) {
+      hosts = await fs.promises.readFile(hostsFile, "utf8")
       if (hosts.startsWith("{}")) {
         hosts = ""
       }
     }
-    let connected = (hosts.length > 0)
+    const connected = hosts.length > 0
+
     let remote = null
-    if (config["remote \"origin\""]) {
+    if (config && config["remote \"origin\""]) {
       remote = config["remote \"origin\""].url
     }
 
-    // Get all remotes
     let remotes = []
     try {
       remotes = await git.listRemotes({ fs, dir, verbose: true })
-    } catch (e) {
-      console.log("Remotes error", e)
-    }
+    } catch (_) {}
 
-    let branch = await git.currentBranch({ fs, dir, fullname: false });
+    if (!currentBranch) {
+      currentBranch = 'HEAD'
+    }
 
-    const remote2 = await git.getConfig({
-      fs,
+    return {
+      ref,
+      config,
+      remote,
+      remotes,
+      connected,
+      log,
+      branch: currentBranch,
+      branches,
       dir,
-      path: `branch.${branch}.remote`
-    });
-
-    // if current branch exitss => currengt branch is selected
-    // if current branch does not exist => get logs[0].oid
-    if (branch) {
-      branches = branches.map((b) => {
-        if (b === branch) {
-          return {
-            branch: b,
-            selected: true
-          }
-        } else {
-          return {
-            branch: b,
-            selected: false
-          }
-        }
-      })
-    } else {
-      branches.push(log[0].oid)
-      branches = branches.map((b) => {
-        if (b === log[0].oid) {
-          return {
-            branch: b,
-            selected: true
-          }
-        } else {
-          return {
-            branch: b,
-            selected: false
-          }
-        }
-      })
+      logError: logError ? String(logError.message || logError) : null
     }
-    return { ref, config, remote, remotes, connected, log, branch, branches, dir }
   }
   async init_env(env_dir_path, options) {
     let current = this.kernel.path(env_dir_path, "ENVIRONMENT")
@@ -696,25 +710,28 @@ class Server {
 
     await Environment.init({ name }, this.kernel)
 
-    // copy gitignore from ~pinokio/prototype/system/gitignore if it doesn't exist
-
-
-    let gitignore_path = this.kernel.path("api/" + name + "/.gitignore")
-    let dot_path = this.kernel.path("api", name, "pinokio")
-    let gitignore_template_path = this.kernel.path("prototype/system/gitignore")
-    let template_exists = await this.exists(gitignore_template_path)
-    if (template_exists) {
-      let exists = await this.exists(dot_path)
-      if (exists) {
-        // 1. when importing existing projects (.pinokio exists), don't mess with .gitignore
-      } else {
-        // 2. otherwise, merge gitignore
-        await Util.mergeLines(
-          gitignore_path, // existing path
-          gitignore_template_path // overwrite with template
-        )
-      }
-    }
+  /*
+  REPLACED OUT WITH using .git/info/exclude instead in order to not mess with 3rd party project .gitignore files but still exclude
+  */
+//    // copy gitignore from ~pinokio/prototype/system/gitignore if it doesn't exist
+//
+//
+//    let gitignore_path = this.kernel.path("api/" + name + "/.gitignore")
+//    let dot_path = this.kernel.path("api", name, "pinokio")
+//    let gitignore_template_path = this.kernel.path("prototype/system/gitignore")
+//    let template_exists = await this.exists(gitignore_template_path)
+//    if (template_exists) {
+//      let exists = await this.exists(dot_path)
+//      if (exists) {
+//        // 1. when importing existing projects (.pinokio exists), don't mess with .gitignore
+//      } else {
+//        // 2. otherwise, merge gitignore
+//        await Util.mergeLines(
+//          gitignore_path, // existing path
+//          gitignore_template_path // overwrite with template
+//        )
+//      }
+//    }
 
 
 
@@ -848,7 +865,8 @@ class Server {
       git_history_url: `/info/git/HEAD/${name}`,
       git_status_url: `/info/gitstatus/${name}`,
       git_push_url: `/run/scripts/git/push.json?cwd=${encodeURIComponent(this.kernel.path('api', name))}`,
-      git_create_url: `/run/scripts/git/create.json?cwd=${encodeURIComponent(this.kernel.path('api', name))}`
+      git_create_url: `/run/scripts/git/create.json?cwd=${encodeURIComponent(this.kernel.path('api', name))}`,
+      git_fork_url: `/run/scripts/git/fork.json?cwd=${encodeURIComponent(this.kernel.path('api', name))}`
 //      rawpath,
     }
 //    if (!this.kernel.proto.config) {
@@ -1202,10 +1220,15 @@ class Server {
 
     const repoHistoryUrl = repoParam ? `/info/git/HEAD/${repoParam}` : null
 
+    const forkUrl = `/run/scripts/git/fork.json?cwd=${encodeURIComponent(dir)}`
+    const pushUrl = `/run/scripts/git/push.json?cwd=${encodeURIComponent(dir)}`
+
     return {
       changes,
       git_commit_url: `/run/scripts/git/commit.json?cwd=${dir}&callback_target=parent&callback=$location.href`,
       git_history_url: repoHistoryUrl,
+      git_fork_url: forkUrl,
+      git_push_url: pushUrl,
     }
   }
   async computeWorkspaceGitStatus(workspaceName) {
@@ -1218,7 +1241,7 @@ class Server {
     for (const repo of repos) {
       const repoParam = repo.gitParentRelPath || workspaceName
       try {
-        const { changes, git_commit_url, git_history_url } = await this.getRepoHeadStatus(repoParam)
+        const { changes, git_commit_url, git_history_url, git_fork_url, git_push_url } = await this.getRepoHeadStatus(repoParam)
         const historyUrl = git_history_url || (repoParam ? `/info/git/HEAD/${repoParam}` : `/info/git/HEAD/${workspaceName}`)
         statuses.push({
           name: repo.name,
@@ -1229,6 +1252,8 @@ class Server {
           changes,
           git_commit_url,
           git_history_url: historyUrl,
+          git_fork_url,
+          git_push_url,
           url: repo.url || null,
         })
       } catch (error) {
@@ -1243,6 +1268,8 @@ class Server {
           changes: [],
           git_commit_url: null,
           git_history_url: historyUrl,
+          git_fork_url: `/run/scripts/git/fork.json?cwd=${encodeURIComponent(this.kernel.path('api', repoParam))}`,
+          git_push_url: `/run/scripts/git/push.json?cwd=${encodeURIComponent(this.kernel.path('api', repoParam))}`,
           url: repo.url || null,
           error: error ? String(error.message || error) : 'unknown',
         })
@@ -4071,11 +4098,14 @@ class Server {
         defaultUrl.searchParams.set('mode', 'settings')
       }
 
+      const initialPath = initialUrl.pathname + initialUrl.search + initialUrl.hash
+      const defaultPath = defaultUrl.pathname + defaultUrl.search + defaultUrl.hash
+
       res.render('layout', {
         theme: this.theme,
         agent: req.agent,
-        initialPath: initialUrl.pathname + initialUrl.search + initialUrl.hash,
-        defaultPath: defaultUrl.pathname + defaultUrl.search + defaultUrl.hash,
+        initialPath,
+        defaultPath,
         sessionId: typeof req.query.session === 'string' ? req.query.session : null
       })
     }))
@@ -5519,7 +5549,6 @@ class Server {
 //    }))
     this.app.post("/env", ex(async (req, res) => {
       let fullpath = path.resolve(this.kernel.homedir, req.body.filepath, "ENVIRONMENT")
-      console.log({ fullpath })
       let updated = req.body.vals
       let hosts = req.body.hosts
       await Util.update_env(fullpath, updated)

package/server/public/layout.js

@@ -37,6 +37,26 @@
   const leafElements = new Map();
   const gutterElements = new Map();
   const layoutCache = new Map();
+  const PRESERVED_QUERY_PARAMS = new Set(['session']);
+
+  function stripTransientQueryParams() {
+    try {
+      const url = new URL(window.location.href);
+      let changed = false;
+      const keys = Array.from(url.searchParams.keys());
+      keys.forEach((key) => {
+        if (!PRESERVED_QUERY_PARAMS.has(key)) {
+          url.searchParams.delete(key);
+          changed = true;
+        }
+      });
+      if (changed) {
+        window.history.replaceState(window.history.state, '', url.toString());
+      }
+    } catch (_) {
+      // ignore malformed URLs
+    }
+  }
 
   function normalizeSrc(raw) {
     if (!raw || typeof raw !== 'string') {
@@ -698,6 +718,7 @@
     applyLayout();
     attachGutterHandlers();
     broadcastLayoutState();
+    stripTransientQueryParams();
   }
 
   function onResize() {