โปรแกรม.pinokio.computer

ปิโนคิโอ

การแนะนำ

Pinokio เป็นเบราว์เซอร์ที่ให้คุณ ติดตั้ง เรียกใช้ และทำให้ AI ใดๆ บนคอมพิวเตอร์ของคุณเป็นแบบอัตโนมัติ ทุกสิ่งที่คุณเรียกใช้ในบรรทัดคำสั่งสามารถทำงาน อัตโนมัติด้วยสคริปต์ Pinokio พร้อม UI ที่ใช้งานง่าย

คุณสามารถใช้ Pinokio เพื่อทำให้ทุกอย่างเป็นอัตโนมัติ ซึ่งรวมถึง:

1. ติดตั้งแอปและโมเดล AI

2. จัดการและเรียกใช้แอป AI

3. สร้างเวิร์กโฟลว์เพื่อประสานแอป AI ที่ติดตั้ง

4. เรียกใช้คำสั่งใดๆ เพื่อทำให้สิ่งต่างๆ บนเครื่องของคุณเป็นอัตโนมัติ

5. และอื่นๆ...

คุณสมบัติ

สิ่งที่ทำให้ Pinokio พิเศษมีดังนี้:

1. ท้องถิ่น: ทุกอย่างได้รับการติดตั้งและทำงานภายในเครื่อง ไม่มีข้อมูลของคุณถูกเก็บไว้บนเซิร์ฟเวอร์ของผู้อื่น

2. ฟรี: Pinokio เป็นแอปพลิเคชันโอเพ่นซอร์สที่ใช้งานได้ฟรี 100% โดยไม่มีข้อจำกัด ไม่มีใครจ่ายเงินสำหรับการเข้าถึง API เนื่องจากทุกอย่างทำงานบนเครื่องภายในของคุณ เล่นกับ AI ได้มากเท่าที่คุณต้องการฟรีตลอดไป

3. ส่วนตัว: คุณไม่จำเป็นต้องกังวลเกี่ยวกับการส่งข้อมูลส่วนตัวเพื่อใช้งาน AI ทุกอย่างจะทำงานแบบส่วนตัว 100% บนเครื่องของคุณเอง

4. อินเทอร์เฟซที่ใช้งานง่าย: Pinokio มี GUI ที่เป็นมิตรต่อผู้ใช้สำหรับการรันและดำเนินการทุกอย่างอัตโนมัติที่ปกติคุณจะต้องใช้เทอร์มินัล

5. รวมแบตเตอรี่: Pinokio เป็นระบบในตัวเอง คุณไม่จำเป็นต้องติดตั้งโปรแกรมอื่นใด Pinokio สามารถทำให้ทุกสิ่งเป็นแบบอัตโนมัติ รวมถึงการติดตั้งโปรแกรม/ไลบรารี โปรแกรมเดียวที่คุณต้องการคือ Pinokio

6. ข้ามแพลตฟอร์ม: Pinokio ทำงานบนระบบปฏิบัติการทั้งหมด (Windows, Mac, Linux)

7. ประหยัดพื้นที่จัดเก็บและทรัพยากร: Pinokio มีคุณสมบัติการเพิ่มประสิทธิภาพมากมายที่จะช่วยคุณประหยัดพื้นที่ดิสก์หลายร้อยกิกะไบต์ นอกจากนี้ ยังมีฟีเจอร์การเพิ่มประสิทธิภาพทรัพยากรอื่นๆ อีกมากมาย (เช่น หน่วยความจำ) ทั้งหมดนี้เป็นไปได้ด้วย Pinokio

8. ภาษาสคริปต์ที่แสดงออก: สคริปต์ Pinokio เป็นภาษาสคริปต์อัตโนมัติที่ทรงพลังพร้อมฟีเจอร์ต่างๆ เช่น หน่วยความจำ เทมเพลตแบบไดนามิก และ API ระดับต่ำที่ขยายได้

9. แบบพกพา: ทุกอย่างจะถูกจัดเก็บไว้ในโฟลเดอร์แยกและทุกอย่างมีอยู่เป็นไฟล์ ซึ่งหมายความว่าคุณสามารถสำรองข้อมูลทุกอย่างหรือลบแอพได้อย่างง่ายดายเพียงแค่ลบไฟล์

---

สถาปัตยกรรม

Pinokio ได้รับแรงบันดาลใจจากวิธีการทำงานของคอมพิวเตอร์แบบดั้งเดิม

เช่นเดียวกับที่คอมพิวเตอร์สามารถทำสิ่งต่าง ๆ ได้ทุกประเภทด้วยสถาปัตยกรรมที่ครอบคลุม Pinokio ซึ่งเป็นคอมพิวเตอร์เสมือนนั้นเป็นแพลตฟอร์มที่ครอบคลุมสำหรับการรันและทำให้ทุกสิ่งที่คุณสามารถจินตนาการได้ด้วย AI เป็นแบบอัตโนมัติ

1. ระบบไฟล์: Pinokio จัดเก็บไฟล์ที่ไหนและอย่างไร

2. ตัวประมวลผล: Pinokio ทำงานอย่างไร

3. หน่วยความจำ: วิธีที่ pinokio ใช้งานเครื่องสถานะโดยใช้หน่วยความจำเนทิฟในตัว

4. สคริปต์: ภาษาโปรแกรมที่ทำงาน pinokio

5. UI: UI (อินเทอร์เฟซผู้ใช้) ที่ผู้ใช้เข้าถึงแอป

---

ติดตั้ง

1. หน้าต่าง

2. แม็ค

3. ลินุกซ์

หน้าต่าง

อย่าลืมทำตาม ขั้นตอนทั้งหมดด้านล่าง!

ขั้นตอนที่ 1 ดาวน์โหลด

ดาวน์โหลดสำหรับ Windows

ขั้นตอนที่ 2 แตกไฟล์

แตกไฟล์ที่ดาวน์โหลดมาแล้วคุณจะเห็นไฟล์ตัวติดตั้ง .exe

ขั้นตอนที่ 3 ติดตั้ง

เรียกใช้ไฟล์ตัวติดตั้ง จากนั้นคุณจะพบคำเตือน Windows ต่อไปนี้:

ข้อความนี้ปรากฏขึ้นเนื่องจากมีการดาวน์โหลดแอปจากเว็บ และนี่คือสิ่งที่ Windows ทำกับแอปที่ดาวน์โหลดจากเว็บ

เพื่อหลีกเลี่ยงสิ่งนี้

1. คลิก "ข้อมูลเพิ่มเติม"

2. จากนั้นคลิก "เรียกใช้ต่อไป"

---

แม็ค

อย่าลืมปฏิบัติตาม ทั้งขั้นตอนที่ 1 และขั้นตอนที่ 2

ขั้นตอนที่ 1 ดาวน์โหลด

ดาวน์โหลดสำหรับ Apple Silicon Mac (M1/M2/M3/M4) ดาวน์โหลดสำหรับ Intel Mac

ขั้นตอนที่ 2 ติดตั้ง (สำคัญ!!)

หลังจากดาวน์โหลดไฟล์ dmg แล้ว คุณต้องสร้างแพตช์ ดังที่แสดงด้านล่าง:

1. เรียกใช้ไฟล์ตัวติดตั้ง DMG ที่ดาวน์โหลดมา

2. ลากแอป "Pinokio" ไปที่โฟลเดอร์ Applications

3. เรียกใช้ "patch.command"

4. เปิดแอป Pinokio ในโฟลเดอร์แอปพลิเคชัน

---

ลินุกซ์

สำหรับ linux คุณสามารถดาวน์โหลดและติดตั้งได้โดยตรงจากรีลีสล่าสุดบน Github (เลื่อนลงไปที่ด้านล่างของหน้าเพื่อดูไบนารีทั้งหมด):

ไปที่หน้าการเผยแพร่

---

ความช่วยเหลือจากชุมชน

เพื่อให้อยู่เหนือ API ใหม่และการผสานรวมแอปทั้งหมด

เอ็กซ์ (ทวิตเตอร์)

ติดตาม @cocktailpeanut บน X เพื่อติดตามสคริปต์ใหม่ทั้งหมดที่ออกและอัปเดตฟีเจอร์ต่างๆ

ความไม่ลงรอยกัน

เข้าร่วมความไม่ลงรอยกันของ Pinokio เพื่อถามคำถามและรับความช่วยเหลือ

---

เริ่มต้นอย่างรวดเร็ว

ระบบไฟล์ Pinokio

Pinokio เป็นแพลตฟอร์มแบบครบวงจรที่ให้คุณติดตั้งแอปในลักษณะแยกส่วนได้

1. สภาพแวดล้อมที่แยกส่วน: ไม่จำเป็นต้องกังวลเกี่ยวกับการกำหนดค่าระบบและสภาพแวดล้อมทั่วโลกที่ยุ่งเหยิง

2. รวมแบตเตอรี่: ไม่จำเป็นต้องติดตั้งโปรแกรมที่จำเป็นด้วยตนเองเพียงเพื่อติดตั้งบางอย่าง (เช่น ffpeg , node.js , Visual Studio , conda , python , pip ฯลฯ ) Pinokio จะดูแลมันโดยอัตโนมัติ

เพื่อให้บรรลุเป้าหมายนี้ Pinokio จะจัดเก็บทุกอย่างไว้ในโฟลเดอร์แยกเพียงโฟลเดอร์เดียว ("pinokio home") ดังนั้นจึงไม่ต้องพึ่งพาการกำหนดค่าและโปรแกรมทั่วทั้งระบบ แต่เรียกใช้ทุกอย่างในลักษณะที่สมบูรณ์ในตัวเอง

คุณสามารถตั้งค่าโฟลเดอร์ หลักของ Pinokio ได้เมื่อคุณตั้งค่า Pinokio เป็นครั้งแรก และเปลี่ยนไปยังตำแหน่งใหม่ในภายหลังจากแท็บ การตั้งค่า

แล้วไฟล์ต่างๆ จะถูกเก็บไว้ที่ไหน? คลิกปุ่ม "ไฟล์" จากหน้าแรก:

นี่จะเป็นการเปิดโฟลเดอร์หลักของ Pinokio ใน File Explorer ของคุณ:

มาดูกันว่าแต่ละโฟลเดอร์ทำอะไรกันบ้าง:

1. api : เก็บแอพที่ดาวน์โหลดทั้งหมด (สคริปต์)

• โฟลเดอร์ภายในโฟลเดอร์นี้จะแสดงอยู่ในบ้านของ Pinokio

2. bin : จัดเก็บโมดูลที่ติดตั้งทั่วโลกซึ่งแชร์โดยหลายแอป ดังนั้นคุณไม่จำเป็นต้องติดตั้งซ้ำซ้อน

• ตัวอย่างเช่น ffmpeg , nodejs , python เป็นต้น

3. cache : เก็บไฟล์ทั้งหมดที่แคชโดยอัตโนมัติโดยแอพที่คุณเรียกใช้

• เมื่อบางอย่างใช้งานไม่ได้ การลบโฟลเดอร์นี้และเริ่มใหม่อาจช่วยแก้ปัญหาได้

• คุณสามารถลบโฟลเดอร์ cache ได้ เนื่องจากจะมีการเติมข้อมูลใหม่โดยแอปที่คุณใช้เมื่อคุณเริ่มใช้แอป

4. drive : เก็บไดรฟ์เสมือนทั้งหมดที่สร้างโดย fs.link Pinokio API

5. logs : เก็บไฟล์บันทึกทั้งหมดสำหรับแต่ละแอป

คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับระบบไฟล์ได้ที่นี่

---

สวัสดีชาวโลก

มาเขียนสคริปต์ที่โคลนพื้นที่เก็บข้อมูลคอมไพล์

1. สร้างโฟลเดอร์ชื่อ helloworld ภายใต้โฟลเดอร์ Pinokio api

2. สร้างไฟล์ชื่อ git.json ใต้โฟลเดอร์ Pinokio api/helloworld

 { "run": [{"method": "shell.run", "params": { "message": "git clone https://github.com/pinokiocomputer/test"}
  -
-

ตอนนี้เมื่อคุณกลับไปที่ Pinokio คุณจะเห็นพื้นที่เก็บ helloworld ของคุณปรากฏขึ้น นำทางเข้าไปแล้วคลิกแท็บ git.json เพื่อเรียกใช้:

คุณจะเห็นว่าโฟลเดอร์ api/helloworld/test ได้รับการโคลนจาก https://github.com/pinokiocomputer/test repository

---

เทมเพลต

นอกจากนี้เรายังสามารถเปลี่ยนคำสั่งที่จะรันและวิธีการรันแบบไดนามิกได้โดยใช้เทมเพลต

ตามตัวอย่าง เรามาเขียนสคริปต์ที่รัน dir บน windows และ ls บน linux และ mac

ในโฟลเดอร์ api/helloworld ของคุณ ให้สร้างไฟล์ชื่อ files.json :

 { "run": [{"method": "shell.run", "params": { "message": "{{platform === 'win32' ? 'dir' : 'ls'}}"}
  -
-

1. นิพจน์เทมเพลต {{ }} มีนิพจน์ JavaScript

2. มีตัวแปรหลายตัวที่พร้อมใช้งานภายในนิพจน์เทมเพลตทุกรายการ และหนึ่งในนั้นคือแพลตฟอร์ม

3. ค่าของ platform คือ darwin (mac), win32 (windows) หรือ linux (linux)

ซึ่งหมายความว่าบน Windows สคริปต์ด้านบนจะเทียบเท่ากับ:

 { "run": [{"method": "shell.run", "params": { "ข้อความ": "dir"}
  -
-

หรือหากไม่ใช่ windows (mac หรือ linux) ก็เทียบเท่ากับ:

 { "run": [{"method": "shell.run", "params": { "ข้อความ": "ls"}
  -
-

คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับเทมเพลตได้ที่นี่

---

ทำงานในโหมดภูต

เมื่อสคริปต์ Pinokio ทำงานเสร็จสิ้น ทุกเซสชันของเชลล์ที่สร้างผ่านสคริปต์จะถูกกำจัดทิ้ง และกระบวนการที่เกี่ยวข้องทั้งหมดจะถูกปิดตัวลง

ตัวอย่างเช่น ลองเปิดเว็บเซิร์ฟเวอร์ท้องถิ่นโดยใช้ http-server สร้างโฟลเดอร์ใหม่ชื่อ httpserver ภายใต้โฟลเดอร์ Pinokio api และสร้างสคริปต์ใหม่ชื่อ index.json :

 { "run": [{"method": "shell.run", "params": { "message": "npx -y http-server"}
  -
-

จากนั้นกลับไปที่ Pinokio แล้วคุณจะเห็นแอปนี้ปรากฏขึ้นที่หน้าแรก คลิกผ่านและคลิกแท็บ index.json บนแถบด้านข้าง จากนั้นสคริปต์จะเริ่มต้นซึ่งควรเปิดเว็บเซิร์ฟเวอร์โดยใช้ npx http-server

แต่ปัญหาคือทันทีที่เปิดตัวเซิร์ฟเวอร์ มันจะปิดตัวลงทันที และคุณจะไม่สามารถใช้เว็บเซิร์ฟเวอร์ได้

เนื่องจาก Pinokio จะปิดกระบวนการทั้งหมดที่เกี่ยวข้องกับสคริปต์โดยอัตโนมัติ เมื่อรันขั้นตอนทั้งหมดใน run array เสร็จสิ้น

เพื่อหลีกเลี่ยงปัญหานี้ คุณต้องบอก Pinokio ว่าแอปนี้ควรจะคงอยู่ต่อไปแม้ว่าจะทำตามขั้นตอนทั้งหมดแล้วก็ตาม เราเพียงแค่ต้องเพิ่มแอตทริบิวต์ daemon :

 { "daemon": true, "run": [{"method": "shell.run", "params": { "message": "npx -y http-server"}
  -
-

ตอนนี้ลองเริ่มสคริปต์อีกครั้ง แล้วคุณจะเห็นว่าเว็บเซิร์ฟเวอร์เริ่มทำงานและไม่ได้ปิดตัวลง

เว็บเซิร์ฟเวอร์จะให้บริการไฟล์ทั้งหมดในโฟลเดอร์ปัจจุบัน (ในกรณีนี้คือ index.json ) เช่นนี้

คุณสามารถหยุดสคริปต์ได้โดยกดปุ่ม "หยุด" ที่ด้านบนของหน้า

เรียนรู้เพิ่มเติมเกี่ยวกับโหมด daemon ที่นี่

---

เรียกใช้หลายคำสั่ง

คุณยังสามารถรันหลายคำสั่งด้วยการเรียก shell.run เพียงครั้งเดียว

เรามาลองตัวอย่างกัน เราจะติดตั้ง เริ่มต้น และเปิดตัวเอ็นจิ้นเอกสารประกอบในสคริปต์เดียว

สิ่งต่างๆ เช่นนี้เคยไม่สามารถเข้าถึงได้สำหรับคนทั่วไป (เนื่องจากคุณต้องเรียกใช้สิ่งเหล่านี้ในเทอร์มินัล) แต่ด้วย Pinokio มันง่ายเพียงแค่คลิกเดียว

1. สร้างโฟลเดอร์ชื่อ docsify ใต้โฟลเดอร์ Pinokio api

2. สร้างไฟล์ชื่อ index.json ใต้โฟลเดอร์ api/docsify ไฟล์ index.json ควรมีลักษณะดังนี้:

 { "daemon": true, "run": [{"method": "shell.run", "params": { "message": ["npx -y docsify-cli init docs", "npx -y docsify-" cli ให้บริการเอกสาร" ]
    -
  -
-

ตัวอย่างนี้ทำ 2 สิ่ง:

1. เริ่มต้นโครงการเอกสาร Docsify

2. เปิดเซิร์ฟเวอร์ docsify dev

เมื่อคุณคลิกลิงก์เซิร์ฟเวอร์ dev จากเทอร์มินัล Pinokio มันจะเปิดหน้าเอกสารในเว็บเบราว์เซอร์:

เรียนรู้เพิ่มเติมเกี่ยวกับ shell.run API ที่นี่

---

ติดตั้งแพ็คเกจลงใน venv

กรณีการใช้งานทั่วไปประการหนึ่งสำหรับ Pinokio คือ:

1. สร้าง/เปิดใช้งาน venv

2. ติดตั้งการพึ่งพาลงใน venv ที่เปิดใช้งาน

ลองตัวอย่างง่ายๆ ตัวอย่างนี้เป็นแอป gradio แบบขั้นต่ำจากบทช่วยสอน gradio อย่างเป็นทางการ

ขั้นแรก สร้างโฟลเดอร์ชื่อ gradio_demo ใต้โฟลเดอร์ api ของ Pinokio

จากนั้น สร้างไฟล์ชื่อ app.py ในโฟลเดอร์ api/gradio_demo

 # app.pyimport gradio เป็น grdef ทักทาย(ชื่อ, ความเข้มข้น): return "Hello, " + name + "!" * int(intensity)demo = gr.Interface(fn=greet,inputs=["text", "slider"],outputs=["text"],
)เดโม.เปิดตัว()

เรายังจำเป็นต้องมีไฟล์ requirements.txt ที่มีลักษณะดังนี้:

# requirements.txt
gradio

สุดท้ายนี้ เราต้องการสคริปต์ install.json ที่จะติดตั้งการขึ้นต่อกันจากไฟล์ requirements.txt :

 { "run": [{"method": "shell.run", "params": { "venv": "env", "message": "pip ติดตั้ง -r ข้อกำหนด.txt"}
  -
-

โครงสร้างโฟลเดอร์จะมีลักษณะดังนี้:

/PINOKIO_HOME
  /api
    /gradio_demo
      app.py
      requirements.txt
      install.json

กลับไปที่ Pinokio แล้วคุณจะเห็นแอป gradio_demo คลิกเข้าไปใน UI แล้วคลิกแท็บ install.json และจะ:

1. สร้างโฟลเดอร์ venv ที่ path env

2. เปิดใช้งานสภาพแวดล้อม env

3. รัน pip install -r requirements.txt ซึ่งจะติดตั้งการพึ่งพา gradio ในสภาพแวดล้อม env

กระบวนการติดตั้งมีลักษณะดังนี้ (โปรดทราบว่ามีการสร้างโฟลเดอร์ env ใหม่ในตอนท้าย):

เรียนรู้เพิ่มเติมเกี่ยวกับ venv API ที่นี่

---

เรียกใช้แอปใน venv

ต่อจากส่วนสุดท้าย

ตอนนี้เรามาเขียนสคริปต์ง่ายๆ ที่จะเปิดตัวเซิร์ฟเวอร์ gradio จาก app.py จากส่วนสุดท้าย สร้างไฟล์ชื่อ start.json ในโฟลเดอร์เดียวกัน:

 { "daemon": true, "run": [{"method": "shell.run", "params": { "venv": "env", "message": "python app.py"}
  -
-

กลับไปที่ Pinokio แล้วคุณจะเห็นว่าไฟล์ start.json ปรากฏบนแถบด้านข้างเช่นกัน คลิกเพื่อเริ่มสคริปต์ start.json สิ่งนี้จะ:

1. เปิดใช้งานสภาพแวดล้อม env ที่เราสร้างจากขั้นตอนการติดตั้ง

2. รัน python app.py ใน โหมด daemon ( daemon: true ) ซึ่งจะเปิดตัวเซิร์ฟเวอร์ gradio และให้มันทำงานต่อไป

มันจะมีลักษณะดังนี้:

เรียนรู้เพิ่มเติมเกี่ยวกับ venv API ที่นี่

---

ดาวน์โหลดไฟล์

Pinokio มี API ข้ามแพลตฟอร์มสำหรับการดาวน์โหลดไฟล์ได้อย่างง่ายดายและเชื่อถือได้ (รวมถึงการลองใหม่อัตโนมัติ ฯลฯ)

ลองเขียนสคริปต์ง่ายๆ เพื่อดาวน์โหลดไฟล์ PDF

ขั้นแรกให้สร้างโฟลเดอร์ชื่อ download ใต้โฟลเดอร์ Pinokio api จากนั้นสร้างไฟล์ชื่อ index.json :

 { "run": [{"method": "fs.download", "params": { "uri": "https://arxiv.org/pdf/1706.03762.pdf", "dir": "pdf"}
  -
-

การดำเนินการนี้จะดาวน์โหลดไฟล์ที่ https://arxiv.org/pdf/1706.03762.pdf ไปยังโฟลเดอร์ชื่อ pdf ( fs.download API จะสร้างโฟลเดอร์ที่ตำแหน่งนั้นโดยอัตโนมัติหากไม่มีอยู่) นี่คือสิ่งที่ดูเหมือน:

เรียนรู้เพิ่มเติมเกี่ยวกับ fs.download API ที่นี่

---

เรียกสคริปต์จากสคริปต์อื่น

ในหลายกรณี คุณอาจต้องการเรียกใช้สคริปต์จากสคริปต์อื่น ตัวอย่างบางส่วน:

1. สคริปต์เรียบเรียงที่หมุน stable diffusion แล้วตาม llama

2. เอเจนต์ที่เริ่ม stable diffusion และร้องขอเพื่อสร้างอิมเมจทันที และสุดท้ายก็หยุดเซิร์ฟเวอร์ stable diffusion เพื่อประหยัดทรัพยากรโดยอัตโนมัติ

3. เอเจนต์ที่ส่งคำขอไปยังจุดสิ้นสุด llama จากนั้นป้อนการตอบสนองต่อจุดสิ้นสุด stable diffusion

เราสามารถทำได้โดยใช้ script API:

• script.start : เริ่มสคริปต์ระยะไกล (ดาวน์โหลดก่อนหากยังไม่มี)

• script.return : หากสคริปต์ปัจจุบันเป็นกระบวนการลูก ให้ระบุค่าที่ส่งคืน ซึ่งจะพร้อมใช้งานในขั้นตอนถัดไปของสคริปต์ผู้เรียก

นี่คือตัวอย่าง มาสร้าง caller.json และ callee.json ง่ายๆ กัน:

caller.json :

 { "run": [{"method": "script.start", "params": { "uri": "callee.json", "params": { "a": 1, "b": 2 }
    -
  }, {"วิธีการ": "log", "พารามิเตอร์": { "json2": "{{input}}"}
  -
-

ขั้นตอนแรก caller.json จะเรียก callee.json พร้อมด้วยพารามิเตอร์ { "a": 1, "b": 2 }

อ็อบเจ็กต์ params นี้จะถูกส่งผ่านไปยัง callee.json เป็น args :

callee.json :

 { "run": [{"method": "script.return", "params": { "ressponse": "{{args.a + args.b}}"}
  -
-

สคริปต์ callee.json ส่งคืนค่า {{args.a + args.b}} ทันทีด้วยการเรียก script.return

สุดท้าย caller.json จะเรียก log ขั้นตอนสุดท้าย ซึ่งจะพิมพ์ค่า {{input}} ซึ่งเป็นค่าที่ส่งคืนจาก callee.json สิ่งนี้จะพิมพ์ 3 :

---

ติดตั้ง เริ่มต้น และหยุดสคริปต์ระยะไกล

ส่วนสุดท้ายจะอธิบายวิธีการเรียกใช้สคริปต์จากภายในพื้นที่เก็บข้อมูลเดียวกัน แต่ถ้าคุณต้องการเรียกสคริปต์จากแหล่งเก็บข้อมูลอื่นล่ะ?

script.start API ยังสามารถดาวน์โหลดและเรียกใช้สคริปต์ระยะไกลได้ทันที

สร้างโฟลเดอร์ชื่อ remotescript ภายใต้โฟลเดอร์ Pinokio api และสร้างไฟล์ชื่อ install.json ภายใต้ api/remotescript :

 { "run": [{"method": "script.start", "params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/install.js"}
  }, {"method": "script.start", "params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/start.js"}
  }, {"id": "run", "method": "gradio.predict", "params": { "uri": "{{kernel.script.local('https://github.com/cocktailpeanutlabs/ moondream2.git/start.js').url}}", "เส้นทาง": "/answer_question_1", "พารามิเตอร์": [
        { "path": "https://media.timeout.com/images/105795964/750/422/image.jpg" },"อธิบายว่าเกิดอะไรขึ้นที่นี่" ]
    -
  }, {"วิธีการ": "log", "พารามิเตอร์": { "json2": "{{input}}"}
  }, {"method": "script.stop", "params": { "uri": "https://github.com/cocktailpeanutlabs/moondream2.git/start.js"}
  -
-

1. ขั้นตอนแรกเริ่มสคริปต์https://github.com/cocktailpeanutlabs/moondream2.git/install.js

• หากมีพื้นที่เก็บข้อมูล moondream2.git มีอยู่แล้วบน Pinokio มันจะเรียกใช้สคริปต์ install.js

• หากไม่มีอยู่แล้ว Pinokio จะโคลนพื้นที่เก็บข้อมูล https://github.com/cocktailpeanutlabs/moondream2.git ก่อน จากนั้นจึงเริ่มสคริปต์ install.js หลังจากนั้น

2. หลังจากการติดตั้งเสร็จสิ้น จากนั้นจะเปิดแอป gradio โดยใช้สคริปต์ https://github.com/cocktailpeanutlabs/moondream2.git/start.js สคริปต์นี้จะกลับมาหลังจากที่เซิร์ฟเวอร์เริ่มทำงาน

3. ตอนนี้เรารัน gradio.predict โดยใช้ kernel.script.local() API เพื่อรับอ็อบเจ็กต์ตัวแปรโลคัลสำหรับสคริปต์ start.js จากนั้นรับค่า url (ซึ่งตั้งค่าโดยทางโปรแกรมภายใน moondream2.git/start.js สคริปต์)

• โดยพื้นฐานแล้ว ขั้นตอนนี้จะส่งคำขอไปยังปลายทาง gradio เพื่อถาม LLM "อธิบายว่าเกิดอะไรขึ้นที่นี่" โดยส่งรูปภาพ

4. ถัดไป ค่าที่ส่งคืนจาก gradio.predict จะถูกบันทึกไปยังเทอร์มินัลโดยใช้ log API

5. สุดท้ายนี้ เราหยุดสคริปต์ moondream2/start.js เพื่อปิดเซิร์ฟเวอร์ gradio ของ moondream โดยใช้ script.stop API

• หากเราไม่เรียก script.stop แอป moondream2 จะทำงานต่อไปแม้ว่าสคริปต์นี้จะหยุดทำงานก็ตาม

นี่คือสิ่งที่จะมีลักษณะดังนี้:

ความสามารถในการเรียกใช้ script.start จากนั้น script.stop มีประโยชน์มากสำหรับการเรียกใช้ AI บนคอมพิวเตอร์ส่วนบุคคล เนื่องจากคอมพิวเตอร์ส่วนบุคคลส่วนใหญ่ไม่มีหน่วยความจำที่ไม่จำกัด และคอมพิวเตอร์ของคุณจะหน่วยความจำไม่เพียงพออย่างรวดเร็วหากคุณไม่สามารถปิดกลไก AI เหล่านี้ได้ โดยทางโปรแกรม

ด้วย script.stop คุณสามารถเริ่มสคริปต์ รับการตอบสนอง และปิดสคริปต์ทันทีเมื่องานเสร็จสิ้น ซึ่งจะเพิ่มหน่วยความจำระบบ ซึ่งคุณสามารถใช้เพื่อรันงาน AI อื่นๆ ตามมาได้

---

สร้าง UI ด้วย pinokio.js

แอป Pinokio มีโครงสร้างที่เรียบง่าย:

1. ทางลัด: ทางลัดแอปที่แสดงบนหน้าแรกของ Pinokio

2. แอป: เค้าโครง UI หลักสำหรับแอป

Shortcut

App

• เมนู: แถบด้านข้างที่แสดงลิงก์ทั้งหมดที่คุณสามารถเรียกใช้ได้ (รวมถึงสถานะการทำงาน)

• หน้าต่าง: วิวพอร์ตที่แสดง หน้าเว็บ หรือ เทอร์มินัล ที่รันสคริปต์

ตามค่าเริ่มต้น หากคุณไม่มีไฟล์ pinokio.js ในโครงการของคุณ

• ทางลัด จะแสดงชื่อโฟลเดอร์เป็นชื่อ และไอคอนเริ่มต้นเป็นไอคอนของแอป

• เมนู จะแสดงไฟล์ .js หรือ .json ทั้งหมดในรูทที่เก็บของคุณ

แม้ว่าวิธีนี้จะสะดวกสำหรับการเริ่มต้น แต่ก็ไม่ยืดหยุ่นเพียงพอ:

1. คุณไม่สามารถควบคุมสิ่งที่จะแสดงในแถบเมนูได้

2. คุณไม่สามารถควบคุมวิธีการเปิดสคริปต์ได้ (เช่น โดยการส่ง params )

3. คุณไม่สามารถควบคุมวิธีการแสดงแอปได้

• ชื่อของแอปจะเป็นชื่อโฟลเดอร์ของคุณ

• ไม่มีคำอธิบาย

• ไอคอนจะแสดงไอคอนเริ่มต้นเท่านั้น

หากต้องการปรับแต่งลักษณะการทำงานของแอป คุณจะต้องเขียนสคริปต์ UI ชื่อ pinokio.js

มาลองเขียน UI ขั้นต่ำ:

1. สร้างโฟลเดอร์ชื่อ downloader ในโฟลเดอร์ /PINOKIO_HOME/api

2. เพิ่มไอคอนใดๆ ลงในโฟลเดอร์ /PINOKIO_HOME/api/downloader และตั้งชื่อเป็น icon.png

3. สร้างไฟล์ชื่อ /PINOKIO_HOME/api/downloader/download.json

4. สร้างไฟล์ชื่อ /PINOKIO_HOME/api/downloader/pinokio.js

/PINOKIO_HOME/api/downloader/icon.png

/PINOKIO_HOME/api/downloader/download.json

 { "run": [{"method": "shell.run", "params": { "message": "git clone {{input.url}}"}
  -
-

/PINOKIO_HOME/api/downloader/pinokio.js

 โมดูล.ส่งออก = {
  ชื่อ: "ดาวน์โหลดอะไรก็ได้",
  คำอธิบาย: "ดาวน์โหลดที่เก็บ git",
  ไอคอน: "icon.png",
  เมนู: [{ข้อความ: "เริ่ม",href: "download.json",params: { url: "https://github.com/cocktailpeanut/dalai"}
  -

ผลลัพธ์ที่ได้จะมีลักษณะเช่นนี้ใน File Explorer ของคุณ:

ตอนนี้กลับไปที่ Pinokio และรีเฟรช แล้วคุณจะเห็นแอปของคุณปรากฏขึ้น:

• ชื่อจะแสดง Download Anything

• คำอธิบายจะแสดง Download a git repository

• ไอคอนคือ icon.png ที่เราเพิ่มไว้

ตอนนี้เมื่อคุณคลิกเข้าไปในแอป คุณจะเห็นสิ่งต่อไปนี้:

1. คุณจะเห็นรายการเมนู Start

2. คลิกที่นี่เพื่อเรียกใช้ download.json ซึ่งระบุโดยแอตทริบิวต์ href

3. โปรดทราบว่าสคริปต์กำลังส่งค่าของ https://github.com/cocktailpeanut/dalai เป็นค่า params.url

4. params ที่ส่งไปยัง download.json นั้นมีให้ใช้งานเป็นตัวแปร input ดังนั้น git clone {{input.url}} จะถูกสร้างอินสแตนซ์เป็น git clone https://github.com/cocktailpeanut/dalai

---

เผยแพร่สคริปต์ของคุณ

เมื่อคุณมีพื้นที่เก็บข้อมูลสคริปต์ที่ใช้งานได้ คุณสามารถเผยแพร่ไปยังบริการโฮสติ้ง git ใดก็ได้และแบ่งปัน URL และใครๆ ก็สามารถติดตั้งและรันสคริปต์ของคุณได้

---

ติดตั้งสคริปต์จาก git url ใด ๆ

คุณสามารถติดตั้งที่เก็บสคริปต์ pinokio ได้อย่างง่ายดาย:

1. คลิกปุ่ม "ดาวน์โหลดจาก URL" ที่ด้านบนของหน้า Discover

2. ป้อน URL คอมไพล์ (คุณสามารถเลือกระบุสาขาได้เช่นกัน)

---

แสดงรายการสคริปต์ของคุณในไดเร็กทอรี

หากคุณเผยแพร่ไปยัง GitHub คุณสามารถแท็กพื้นที่เก็บข้อมูลของคุณด้วย "pinokio" เพื่อให้แสดงในส่วน "ล่าสุด" ของหน้า Discover

ตอนนี้มันจะแสดงในส่วน "ล่าสุด" โดยอัตโนมัติ (ที่ด้านล่างของหน้า "ค้นพบ"):

Pinokio สร้างส่วน "ล่าสุด" โดยอัตโนมัติจาก GitHub "/repositories" API ที่ https://api.github.com/search/repositories?q=topic:pinokio&sort=updated&direction=desc

ดังนั้น หากคุณแท็กพื้นที่เก็บข้อมูลของคุณเป็น "pinokio" แต่ไม่ปรากฏขึ้น ให้ตรวจสอบผลลัพธ์ของ API และลองหาสาเหตุว่าทำไมจึงไม่รวมอยู่ในนั้น

---

สร้างเครื่องเรียกใช้งานแอปอัตโนมัติ

แม้ว่าสิ่งสำคัญคือต้องเข้าใจว่าทั้งหมดนี้ทำงานอย่างไร แต่ในกรณีส่วนใหญ่คุณอาจต้องการ "คำสั่งผสมตัวเรียกใช้งาน" ที่เรียบง่ายซึ่งรวมถึง:

1. สคริปต์การติดตั้งแอป: ติดตั้งการขึ้นต่อกันของแอป

2. สคริปต์เปิดแอป: เริ่มแอป

3. UI: แสดง UI ตัวเรียกใช้งาน

4. รีเซ็ตสคริปต์: รีเซ็ตสถานะแอปเมื่อมีสิ่งผิดปกติเกิดขึ้น

5. สคริปต์อัปเดต: อัปเดตแอปเป็นเวอร์ชันล่าสุดด้วยการคลิกเพียงครั้งเดียว

กรณีการใช้งานนี้จำเป็นบ่อยครั้ง จนเราได้ติดตั้งโปรแกรมที่สร้างสคริปต์เหล่านี้โดยอัตโนมัติในทันที มันชื่อเกเปโต.

---

การเพิ่มโพสต์ในฟีดข่าว

บ่อยครั้งคุณอาจต้องการแบ่งปันข้อมูลเพิ่มเติมเกี่ยวกับแต่ละสคริปต์ คุณสามารถใช้ฟีดข่าวเพื่อสิ่งนั้นได้

ในการดำเนินการนี้ เพียงสร้างไฟล์ pinokio_meta.json พร้อมด้วยแอตทริบิวต์อาร์เรย์ posts โดยที่แต่ละรายการจะเป็น URL x.com นี่คือตัวอย่าง:

 { "โพสต์": ["https://x.com/cocktailpeanut/status/1819482952071323788","https://x.com/cocktailpeanut/status/1819439443394109837","https://x.com/cocktailpeanut/status /1800944955738685648","https://x.com/cocktailpeanut/status/1754244867159413001","https://x.com/cocktailpeanut/status/1729884460114727197","https://x.com/cocktailpeanut/status/1728075614807048208 "
  -
-

คุณสามารถดูการทำงานจริง: https://github.com/cocktailpeanutlabs/comfyui/blob/main/pinokio_meta.json

เมื่อคุณเผยแพร่ สิ่งนี้จะปรากฏบนแลนดิ้งเพจของสคริปต์ทันที

---

เกเปโต